﻿using System;
using System.Collections;
using System.Diagnostics;
using System.Globalization;
using Microsoft.Practices.ServiceLocation;
using NUnit.Framework;

namespace Eswat.Services.NUnit
{
	/// <summary>
	/// NUnit assertions test service.
	/// </summary>
	public class NUnitTestService : INUnitTestService
	{
		/// <summary>
		/// The default name of this test service.
		/// </summary>
		public const string DefaultServiceName = "Verify";

		private readonly ITestResultLoggingService _testResultLoggingService;

		#region Constructors

		/// <summary>
		/// Initializes a new instance of the <see cref="NUnitTestService"/> class.
		/// </summary>
		public NUnitTestService()
			: this(DefaultServiceName)
		{
		}

		/// <summary>
		/// Initializes a new instance of the <see cref="NUnitTestService"/> class.
		/// </summary>
		/// <param name="name">The name.</param>
		public NUnitTestService(string name)
		{
			this.Name = name;

			this._testResultLoggingService = ServiceLocator.Current.GetInstance<ITestResultLoggingService>();
		}

		/// <summary>
		/// Initializes a new instance of the <see cref="NUnitTestService"/> class.
		/// </summary>
		/// <param name="testResultLoggingService">The test result logging service.</param>
		public NUnitTestService(ITestResultLoggingService testResultLoggingService)
			: this(testResultLoggingService, "Verify")
		{
		}

		/// <summary>
		/// Initializes a new instance of the <see cref="NUnitTestService"/> class.
		/// </summary>
		/// <param name="testResultLoggingService">The test result logging service.</param>
		/// <param name="name">The name.</param>
		public NUnitTestService(
			ITestResultLoggingService testResultLoggingService,
			string name)
		{
			this._testResultLoggingService = testResultLoggingService;

			this.Name = name;
		}

		#endregion

		/// <summary>
		/// Gets the unique service name.
		/// </summary>
		public string Name { get; private set; }

		#region True / False

		/// <summary>
		/// Asserts that a condition is true. If the condition is true the method throws an <see cref="AssertionException"/>.
		/// </summary>
		/// <param name="condition">The evaluated condition.</param>
		public TestResult True(bool condition)
		{
			return this.ExecuteTest(() => Assert.True(condition));
		}

		/// <summary>
		/// Asserts that a condition is true. If the condition is true the method throws an <see cref="AssertionException"/>.
		/// </summary>
		/// <param name="condition">The evaluated condition.</param>
		/// <param name="message">The message to display in case of failure.</param>
		public TestResult True(bool condition, string message)
		{
			return this.ExecuteTest(() => Assert.True(condition, message), message);
		}

		/// <summary>
		/// Asserts that a condition is true. If the condition is true the method throws an <see cref="AssertionException"/>.
		/// </summary>
		/// <param name="condition">The evaluated condition.</param>
		/// <param name="message">The message to display in case of failure.</param>
		/// <param name="args">Array of objects to be used in formatting the message.</param>
		public TestResult True(bool condition, string message, params object[] args)
		{
			return this.ExecuteTest(() => Assert.True(condition, message, args), message, args);
		}

		/// <summary>
		/// Asserts that a condition is true. If the condition is true the method throws an <see cref="AssertionException"/>.
		/// </summary>
		/// <param name="condition">The evaluated condition.</param>
		public TestResult IsTrue(bool condition)
		{
			return this.ExecuteTest(() => Assert.IsTrue(condition));
		}

		/// <summary>
		/// Asserts that a condition is true. If the condition is true the method throws an <see cref="AssertionException"/>.
		/// </summary>
		/// <param name="condition">The evaluated condition.</param>
		/// <param name="message">The message to display in case of failure.</param>
		public TestResult IsTrue(bool condition, string message)
		{
			return this.ExecuteTest(() => Assert.IsTrue(condition, message), message);
		}

		/// <summary>
		/// Asserts that a condition is true. If the condition is true the method throws an <see cref="AssertionException"/>.
		/// </summary>
		/// <param name="condition">The evaluated condition.</param>
		/// <param name="message">The message to display in case of failure.</param>
		/// <param name="args">Array of objects to be used in formatting the message.</param>
		public TestResult IsTrue(bool condition, string message, params object[] args)
		{
			return this.ExecuteTest(() => Assert.IsTrue(condition, message, args), message, args);
		}

		/// <summary>
		/// Asserts that a condition is false. If the condition is true the method throws an <see cref="AssertionException"/>.
		/// </summary>
		/// <param name="condition">The evaluated condition.</param>
		public TestResult False(bool condition)
		{
			return this.ExecuteTest(() => Assert.False(condition));
		}

		/// <summary>
		/// Asserts that a condition is false. If the condition is true the method throws an <see cref="AssertionException"/>.
		/// </summary>
		/// <param name="condition">The evaluated condition.</param>
		/// <param name="message">The message to display in case of failure.</param>
		public TestResult False(bool condition, string message)
		{
			return this.ExecuteTest(() => Assert.False(condition, message), message);
		}

		/// <summary>
		/// Asserts that a condition is false. If the condition is true the method throws an <see cref="AssertionException"/>.
		/// </summary>
		/// <param name="condition">The evaluated condition.</param>
		/// <param name="message">The message to display in case of failure.</param>
		/// <param name="args">Array of objects to be used in formatting the message.</param>
		public TestResult False(bool condition, string message, params object[] args)
		{
			return this.ExecuteTest(() => Assert.False(condition, message, args), message, args);
		}

		/// <summary>
		/// Asserts that a condition is false. If the condition is true the method throws an <see cref="AssertionException"/>.
		/// </summary>
		/// <param name="condition">The evaluated condition.</param>
		public TestResult IsFalse(bool condition)
		{
			return this.ExecuteTest(() => Assert.IsFalse(condition));
		}

		/// <summary>
		/// Asserts that a condition is false. If the condition is true the method throws an <see cref="AssertionException"/>.
		/// </summary>
		/// <param name="condition">The evaluated condition.</param>
		/// <param name="message">The message to display in case of failure.</param>
		public TestResult IsFalse(bool condition, string message)
		{
			return this.ExecuteTest(() => Assert.IsFalse(condition, message), message);
		}

		/// <summary>
		/// Asserts that a condition is false. If the condition is true the method throws an <see cref="AssertionException"/>.
		/// </summary>
		/// <param name="condition">The evaluated condition.</param>
		/// <param name="message">The message to display in case of failure.</param>
		/// <param name="args">Array of objects to be used in formatting the message.</param>
		public TestResult IsFalse(bool condition, string message, params object[] args)
		{
			return this.ExecuteTest(() => Assert.IsFalse(condition, message, args), message, args);
		}

		#endregion

		#region AreEqual

		/// <summary>
		/// Verifies that two values are equal. If they are not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="expected">The expected value.</param>
		/// <param name="actual">The actual value.</param>
		public TestResult AreEqual(decimal expected, decimal actual)
		{
			return this.ExecuteTest(() => Assert.AreEqual(expected, actual));
		}

		/// <summary>
		/// Verifies that two values are equal. If they are not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="expected">The expected value.</param>
		/// <param name="actual">The actual value.</param>
		public TestResult AreEqual(double expected, double actual)
		{
			return this.ExecuteTest(() => Assert.AreEqual(expected, actual, GlobalSettings.DefaultFloatingPointTolerance));
		}

		/// <summary>
		/// Verifies that two values are equal. If they are not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="expected">The expected value.</param>
		/// <param name="actual">The actual value.</param>
		public TestResult AreEqual(float expected, float actual)
		{
			return this.ExecuteTest(() => Assert.AreEqual(expected, actual, GlobalSettings.DefaultFloatingPointTolerance));
		}

		/// <summary>
		/// Verifies that two values are equal. If they are not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="expected">The expected value.</param>
		/// <param name="actual">The actual value.</param>
		public TestResult AreEqual(int expected, int actual)
		{
			return this.ExecuteTest(() => Assert.AreEqual(expected, actual));
		}

		/// <summary>
		/// Verifies that two values are equal. If they are not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="expected">The expected value.</param>
		/// <param name="actual">The actual value.</param>
		public TestResult AreEqual(long expected, long actual)
		{
			return this.ExecuteTest(() => Assert.AreEqual(expected, actual));
		}

		/// <summary>
		///     Verifies that two objects are equal. Two objects are considered equal if
		///     both are null, or if both have the same value. NUnit has special semantics
		///     for some object types.  If they are not equal an <see cref="AssertionException"/>
		///     is thrown.
		/// </summary>
		/// <param name="expected">The expected value.</param>
		/// <param name="actual">The actual value.</param>
		public TestResult AreEqual(object expected, object actual)
		{
			return this.ExecuteTest(() => Assert.AreEqual(expected, actual));
		}

		/// <summary>
		/// Verifies that two values are equal. If they are not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="expected">The expected value.</param>
		/// <param name="actual">The actual value.</param>
		public TestResult AreEqual(uint expected, uint actual)
		{
			return this.ExecuteTest(() => Assert.AreEqual(expected, actual));
		}

		/// <summary>
		/// Verifies that two values are equal. If they are not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="expected">The expected value.</param>
		/// <param name="actual">The actual value.</param>
		public TestResult AreEqual(ulong expected, ulong actual)
		{
			return this.ExecuteTest(() => Assert.AreEqual(expected, actual));
		}

		/// <summary>
		/// Verifies that two values are equal. If they are not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="expected">The expected value.</param>
		/// <param name="actual">The actual value.</param>
		/// <param name="message">The message to display in case of failure.</param>
		public TestResult AreEqual(decimal expected, decimal actual, string message)
		{
			return this.ExecuteTest(() => Assert.AreEqual(expected, actual, message), message);
		}

		/// <summary>
		/// Verifies that two values are equal. If they are not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="expected">The expected value.</param>
		/// <param name="actual">The actual value.</param>
		/// <param name="message">The message to display in case of failure.</param>
		public TestResult AreEqual(float expected, float actual, string message)
		{
			return this.ExecuteTest(() => Assert.AreEqual(expected, actual, GlobalSettings.DefaultFloatingPointTolerance, message), message);
		}

		/// <summary>
		/// Verifies that two values are equal. If they are not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="expected">The expected value.</param>
		/// <param name="actual">The actual value.</param>
		/// <param name="message">The message to display in case of failure.</param>
		public TestResult AreEqual(double expected, double actual, string message)
		{
			return this.ExecuteTest(() => Assert.AreEqual(expected, actual, GlobalSettings.DefaultFloatingPointTolerance, message), message);
		}

		/// <summary>
		///     Verifies that two values are equal. If they are not, then an <see cref="AssertionException"/>
		///     is thrown.
		/// </summary>
		/// <param name="expected">The expected value.</param>
		/// <param name="actual">The actual value.</param>
		/// <param name="message">The message to display in case of failure.</param>
		public TestResult AreEqual(int expected, int actual, string message)
		{
			return this.ExecuteTest(() => Assert.AreEqual(expected, actual, message), message);
		}

		/// <summary>
		/// Verifies that two values are equal. If they are not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="expected">The expected value.</param>
		/// <param name="actual">The actual value.</param>
		/// <param name="message">The message to display in case of failure.</param>
		public TestResult AreEqual(long expected, long actual, string message)
		{
			return this.ExecuteTest(() => Assert.AreEqual(expected, actual, message), message);
		}

		/// <summary>
		///     Verifies that two objects are equal. Two objects are considered equal if
		///     both are null, or if both have the same value. NUnit has special semantics
		///     for some object types.  If they are not equal an <see cref="AssertionException"/>
		///     is thrown.
		/// </summary>
		/// <param name="expected">The expected value.</param>
		/// <param name="actual">The actual value.</param>
		/// <param name="message">The message to display in case of failure.</param>
		public TestResult AreEqual(object expected, object actual, string message)
		{
			return this.ExecuteTest(() => Assert.AreEqual(expected, actual, message), message);
		}

		/// <summary>
		/// Verifies that two values are equal. If they are not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="expected">The expected value.</param>
		/// <param name="actual">The actual value.</param>
		/// <param name="message">The message to display in case of failure.</param>
		public TestResult AreEqual(uint expected, uint actual, string message)
		{
			return this.ExecuteTest(() => Assert.AreEqual(expected, actual, message), message);
		}

		/// <summary>
		/// Verifies that two values are equal. If they are not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="expected">The expected value.</param>
		/// <param name="actual">The actual value.</param>
		/// <param name="message">The message to display in case of failure.</param>
		public TestResult AreEqual(ulong expected, ulong actual, string message)
		{
			return this.ExecuteTest(() => Assert.AreEqual(expected, actual, message), message);
		}

		/// <summary>
		/// Verifies that two values are equal. If they are not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="expected">The expected value.</param>
		/// <param name="actual">The actual value.</param>
		/// <param name="message">The message to display in case of failure.</param>
		/// <param name="args">Array of objects to be used in formatting the message.</param>
		public TestResult AreEqual(decimal expected, decimal actual, string message, params object[] args)
		{
			return this.ExecuteTest(() => Assert.AreEqual(expected, actual, message, args), message, args);
		}

		/// <summary>
		/// Verifies that two values are equal. If they are not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="expected">The expected value.</param>
		/// <param name="actual">The actual value.</param>
		/// <param name="message">The message to display in case of failure.</param>
		/// <param name="args">Array of objects to be used in formatting the message.</param>
		public TestResult AreEqual(float expected, float actual, string message, params object[] args)
		{
			return this.ExecuteTest(() => Assert.AreEqual(expected, actual, GlobalSettings.DefaultFloatingPointTolerance, message, args), message, args);
		}

		/// <summary>
		/// Verifies that two values are equal. If they are not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="expected">The expected value.</param>
		/// <param name="actual">The actual value.</param>
		/// <param name="message">The message to display in case of failure.</param>
		/// <param name="args">Array of objects to be used in formatting the message.</param>
		public TestResult AreEqual(double expected, double actual, string message, params object[] args)
		{
			return this.ExecuteTest(() => Assert.AreEqual(expected, actual, GlobalSettings.DefaultFloatingPointTolerance, message, args), message, args);
		}

		/// <summary>
		/// Verifies that two values are equal. If they are not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="expected">The expected value.</param>
		/// <param name="actual">The actual value.</param>
		/// <param name="message">The message to display in case of failure.</param>
		/// <param name="args">Array of objects to be used in formatting the message.</param>
		public TestResult AreEqual(int expected, int actual, string message, params object[] args)
		{
			return this.ExecuteTest(() => Assert.AreEqual(expected, actual, message, args), message, args);
		}

		/// <summary>
		/// Verifies that two values are equal. If they are not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="expected">The expected value.</param>
		/// <param name="actual">The actual value.</param>
		/// <param name="message">The message to display in case of failure.</param>
		/// <param name="args">Array of objects to be used in formatting the message.</param>
		public TestResult AreEqual(long expected, long actual, string message, params object[] args)
		{
			return this.ExecuteTest(() => Assert.AreEqual(expected, actual, message, args), message, args);
		}

		/// <summary>
		/// Verifies that two objects are equal. Two objects are considered equal if
		/// both are null, or if both have the same value. NUnit has special semantics
		/// for some object types.  If they are not equal an <see cref="AssertionException"/>
		/// is thrown.
		/// </summary>
		/// <param name="expected">The expected value.</param>
		/// <param name="actual">The actual value.</param>
		/// <param name="message">The message to display in case of failure.</param>
		/// <param name="args">Array of objects to be used in formatting the message.</param>
		public TestResult AreEqual(object expected, object actual, string message, params object[] args)
		{
			return this.ExecuteTest(() => Assert.AreEqual(expected, actual, message, args), message, args);
		}

		/// <summary>
		/// Verifies that two values are equal. If they are not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="expected">The expected value.</param>
		/// <param name="actual">The actual value.</param>
		/// <param name="message">The message to display in case of failure.</param>
		/// <param name="args">Array of objects to be used in formatting the message.</param>
		public TestResult AreEqual(uint expected, uint actual, string message, params object[] args)
		{
			return this.ExecuteTest(() => Assert.AreEqual(expected, actual, message, args), message, args);
		}

		/// <summary>
		/// Verifies that two values are equal. If they are not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="expected">The expected value.</param>
		/// <param name="actual">The actual value.</param>
		/// <param name="message">The message to display in case of failure.</param>
		/// <param name="args">Array of objects to be used in formatting the message.</param>
		public TestResult AreEqual(ulong expected, ulong actual, string message, params object[] args)
		{
			return this.ExecuteTest(() => Assert.AreEqual(expected, actual, message, args), message, args);
		}

		/// <summary>
		///     Verifies that two doubles are equal considering a delta. If the expected
		///     value is infinity then the delta value is ignored. If they are not equal
		///     then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="expected">The expected value.</param>
		/// <param name="actual">The actual value.</param>
		/// <param name="delta">The maximum acceptable difference between the the expected and the actual.</param>
		public TestResult AreEqual(double expected, double actual, double delta)
		{
			return this.ExecuteTest(() => Assert.AreEqual(expected, actual, delta));
		}

		/// <summary>
		///     Verifies that two doubles are equal considering a delta. If the expected
		///     value is infinity then the delta value is ignored. If they are not equal
		///     then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="expected">The expected value.</param>
		/// <param name="actual">The actual value.</param>
		/// <param name="delta">The maximum acceptable difference between the the expected and the actual.</param>
		public TestResult AreEqual(double expected, double? actual, double delta)
		{
			return this.ExecuteTest(() => Assert.AreEqual(expected, actual, delta));
		}

		/// <summary>
		/// Verifies that two doubles are equal considering a delta. If the expected
		/// value is infinity then the delta value is ignored. If they are not equal
		/// then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="expected">The expected value.</param>
		/// <param name="actual">The actual value.</param>
		/// <param name="delta">The maximum acceptable difference between the the expected and the actual.</param>
		/// <param name="message">The message to display in case of failure.</param>
		public TestResult AreEqual(double expected, double actual, double delta, string message)
		{
			return this.ExecuteTest(() => Assert.AreEqual(expected, actual, delta, message), message);
		}

		/// <summary>
		/// Verifies that two doubles are equal considering a delta. If the expected
		/// value is infinity then the delta value is ignored. If they are not equal
		/// then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="expected">The expected value.</param>
		/// <param name="actual">The actual value.</param>
		/// <param name="delta">The maximum acceptable difference between the the expected and the actual.</param>
		/// <param name="message">The message to display in case of failure.</param>
		public TestResult AreEqual(double expected, double? actual, double delta, string message)
		{
			return this.ExecuteTest(() => Assert.AreEqual(expected, actual, delta, message), message);
		}

		/// <summary>
		/// Verifies that two doubles are equal considering a delta. If the expected
		/// value is infinity then the delta value is ignored. If they are not equal
		/// then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="expected">The expected value.</param>
		/// <param name="actual">The actual value.</param>
		/// <param name="delta">The maximum acceptable difference between the the expected and the actual.</param>
		/// <param name="message">The message to display in case of failure.</param>
		/// <param name="args">Array of objects to be used in formatting the message.</param>
		public TestResult AreEqual(double expected, double actual, double delta, string message, params object[] args)
		{
			return this.ExecuteTest(() => Assert.AreEqual(expected, actual, delta, message, args), message, args);
		}

		/// <summary>
		/// Verifies that two doubles are equal considering a delta. If the expected
		/// value is infinity then the delta value is ignored. If they are not equal
		/// then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="expected">The expected value.</param>
		/// <param name="actual">The actual value.</param>
		/// <param name="delta">The maximum acceptable difference between the the expected and the actual.</param>
		/// <param name="message">The message to display in case of failure.</param>
		/// <param name="args">Array of objects to be used in formatting the message.</param>
		public TestResult AreEqual(double expected, double? actual, double delta, string message, params object[] args)
		{
			return this.ExecuteTest(() => Assert.AreEqual(expected, actual, delta, message, args), message, args);
		}

		#endregion

		#region AreNotEqual

		/// <summary>
		/// Verifies that two values are not equal. If they are not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="expected">The expected value.</param>
		/// <param name="actual">The actual value.</param>
		public TestResult AreNotEqual(decimal expected, decimal actual)
		{
			return this.ExecuteTest(() => Assert.AreNotEqual(expected, actual));
		}

		/// <summary>
		/// Verifies that two values are not equal. If they are not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="expected">The expected value.</param>
		/// <param name="actual">The actual value.</param>
		public TestResult AreNotEqual(double expected, double actual)
		{
			return this.ExecuteTest(() => Assert.AreNotEqual(expected, actual));
		}

		/// <summary>
		/// Verifies that two values are not equal. If they are not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="expected">The expected value.</param>
		/// <param name="actual">The actual value.</param>
		public TestResult AreNotEqual(float expected, float actual)
		{
			return this.ExecuteTest(() => Assert.AreNotEqual(expected, actual));
		}

		/// <summary>
		/// Verifies that two values are not equal. If they are not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="expected">The expected value.</param>
		/// <param name="actual">The actual value.</param>
		public TestResult AreNotEqual(int expected, int actual)
		{
			return this.ExecuteTest(() => Assert.AreNotEqual(expected, actual));
		}

		/// <summary>
		/// Verifies that two values are not equal. If they are not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="expected">The expected value.</param>
		/// <param name="actual">The actual value.</param>
		public TestResult AreNotEqual(long expected, long actual)
		{
			return this.ExecuteTest(() => Assert.AreNotEqual(expected, actual));
		}

		/// <summary>
		///     Verifies that two objects are not equal. Two objects are considered equal if
		///     both are null, or if both have the same value. NUnit has special semantics
		///     for some object types.  If they are not equal an <see cref="AssertionException"/>
		///     is thrown.
		/// </summary>
		/// <param name="expected">The expected value.</param>
		/// <param name="actual">The actual value.</param>
		public TestResult AreNotEqual(object expected, object actual)
		{
			return this.ExecuteTest(() => Assert.AreNotEqual(expected, actual));
		}

		/// <summary>
		/// Verifies that two values are not equal. If they are not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="expected">The expected value.</param>
		/// <param name="actual">The actual value.</param>
		public TestResult AreNotEqual(uint expected, uint actual)
		{
			return this.ExecuteTest(() => Assert.AreNotEqual(expected, actual));
		}

		/// <summary>
		/// Verifies that two values are not equal. If they are not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="expected">The expected value.</param>
		/// <param name="actual">The actual value.</param>
		public TestResult AreNotEqual(ulong expected, ulong actual)
		{
			return this.ExecuteTest(() => Assert.AreNotEqual(expected, actual));
		}

		/// <summary>
		/// Verifies that two values are not equal. If they are not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="expected">The expected value.</param>
		/// <param name="actual">The actual value.</param>
		/// <param name="message">The message to display in case of failure.</param>
		public TestResult AreNotEqual(decimal expected, decimal actual, string message)
		{
			return this.ExecuteTest(() => Assert.AreNotEqual(expected, actual, message), message);
		}

		/// <summary>
		/// Verifies that two values are not equal. If they are not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="expected">The expected value.</param>
		/// <param name="actual">The actual value.</param>
		/// <param name="message">The message to display in case of failure.</param>
		public TestResult AreNotEqual(float expected, float actual, string message)
		{
			return this.ExecuteTest(() => Assert.AreNotEqual(expected, actual, message), message);
		}

		/// <summary>
		/// Verifies that two values are not equal. If they are not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="expected">The expected value.</param>
		/// <param name="actual">The actual value.</param>
		/// <param name="message">The message to display in case of failure.</param>
		public TestResult AreNotEqual(double expected, double actual, string message)
		{
			return this.ExecuteTest(() => Assert.AreNotEqual(expected, actual, message), message);
		}

		/// <summary>
		///     Verifies that two values are not equal. If they are not, then an <see cref="AssertionException"/>
		///     is thrown.
		/// </summary>
		/// <param name="expected">The expected value.</param>
		/// <param name="actual">The actual value.</param>
		/// <param name="message">The message to display in case of failure.</param>
		public TestResult AreNotEqual(int expected, int actual, string message)
		{
			return this.ExecuteTest(() => Assert.AreNotEqual(expected, actual, message), message);
		}

		/// <summary>
		/// Verifies that two values are not equal. If they are not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="expected">The expected value.</param>
		/// <param name="actual">The actual value.</param>
		/// <param name="message">The message to display in case of failure.</param>
		public TestResult AreNotEqual(long expected, long actual, string message)
		{
			return this.ExecuteTest(() => Assert.AreNotEqual(expected, actual, message), message);
		}

		/// <summary>
		///     Verifies that two objects are not equal. Two objects are considered equal if
		///     both are null, or if both have the same value. NUnit has special semantics
		///     for some object types.  If they are not equal an <see cref="AssertionException"/>
		///     is thrown.
		/// </summary>
		/// <param name="expected">The expected value.</param>
		/// <param name="actual">The actual value.</param>
		/// <param name="message">The message to display in case of failure.</param>
		public TestResult AreNotEqual(object expected, object actual, string message)
		{
			return this.ExecuteTest(() => Assert.AreNotEqual(expected, actual, message), message);
		}

		/// <summary>
		/// Verifies that two values are not equal. If they are not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="expected">The expected value.</param>
		/// <param name="actual">The actual value.</param>
		/// <param name="message">The message to display in case of failure.</param>
		public TestResult AreNotEqual(uint expected, uint actual, string message)
		{
			return this.ExecuteTest(() => Assert.AreNotEqual(expected, actual, message), message);
		}

		/// <summary>
		/// Verifies that two values are not equal. If they are not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="expected">The expected value.</param>
		/// <param name="actual">The actual value.</param>
		/// <param name="message">The message to display in case of failure.</param>
		public TestResult AreNotEqual(ulong expected, ulong actual, string message)
		{
			return this.ExecuteTest(() => Assert.AreNotEqual(expected, actual, message), message);
		}

		/// <summary>
		/// Verifies that two values are not equal. If they are not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="expected">The expected value.</param>
		/// <param name="actual">The actual value.</param>
		/// <param name="message">The message to display in case of failure.</param>
		/// <param name="args">Array of objects to be used in formatting the message.</param>
		public TestResult AreNotEqual(decimal expected, decimal actual, string message, params object[] args)
		{
			return this.ExecuteTest(() => Assert.AreNotEqual(expected, actual, message, args), message, args);
		}

		/// <summary>
		/// Verifies that two values are not equal. If they are not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="expected">The expected value.</param>
		/// <param name="actual">The actual value.</param>
		/// <param name="message">The message to display in case of failure.</param>
		/// <param name="args">Array of objects to be used in formatting the message.</param>
		public TestResult AreNotEqual(float expected, float actual, string message, params object[] args)
		{
			return this.ExecuteTest(() => Assert.AreNotEqual(expected, actual, message, args), message, args);
		}

		/// <summary>
		/// Verifies that two values are not equal. If they are not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="expected">The expected value.</param>
		/// <param name="actual">The actual value.</param>
		/// <param name="message">The message to display in case of failure.</param>
		/// <param name="args">Array of objects to be used in formatting the message.</param>
		public TestResult AreNotEqual(double expected, double actual, string message, params object[] args)
		{
			return this.ExecuteTest(() => Assert.AreNotEqual(expected, actual, message, args), message, args);
		}

		/// <summary>
		/// Verifies that two values are not equal. If they are not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="expected">The expected value.</param>
		/// <param name="actual">The actual value.</param>
		/// <param name="message">The message to display in case of failure.</param>
		/// <param name="args">Array of objects to be used in formatting the message.</param>
		public TestResult AreNotEqual(int expected, int actual, string message, params object[] args)
		{
			return this.ExecuteTest(() => Assert.AreNotEqual(expected, actual, message, args), message, args);
		}

		/// <summary>
		/// Verifies that two values are not equal. If they are not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="expected">The expected value.</param>
		/// <param name="actual">The actual value.</param>
		/// <param name="message">The message to display in case of failure.</param>
		/// <param name="args">Array of objects to be used in formatting the message.</param>
		public TestResult AreNotEqual(long expected, long actual, string message, params object[] args)
		{
			return this.ExecuteTest(() => Assert.AreNotEqual(expected, actual, message, args), message, args);
		}

		/// <summary>
		/// Verifies that two objects are not equal. Two objects are considered equal if
		/// both are null, or if both have the same value. NUnit has special semantics
		/// for some object types.  If they are not equal an <see cref="AssertionException"/>
		/// is thrown.
		/// </summary>
		/// <param name="expected">The expected value.</param>
		/// <param name="actual">The actual value.</param>
		/// <param name="message">The message to display in case of failure.</param>
		/// <param name="args">Array of objects to be used in formatting the message.</param>
		public TestResult AreNotEqual(object expected, object actual, string message, params object[] args)
		{
			return this.ExecuteTest(() => Assert.AreNotEqual(expected, actual, message, args), message, args);
		}

		/// <summary>
		/// Verifies that two values are not equal. If they are not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="expected">The expected value.</param>
		/// <param name="actual">The actual value.</param>
		/// <param name="message">The message to display in case of failure.</param>
		/// <param name="args">Array of objects to be used in formatting the message.</param>
		public TestResult AreNotEqual(uint expected, uint actual, string message, params object[] args)
		{
			return this.ExecuteTest(() => Assert.AreNotEqual(expected, actual, message, args), message, args);
		}

		/// <summary>
		/// Verifies that two values are not equal. If they are not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="expected">The expected value.</param>
		/// <param name="actual">The actual value.</param>
		/// <param name="message">The message to display in case of failure.</param>
		/// <param name="args">Array of objects to be used in formatting the message.</param>
		public TestResult AreNotEqual(ulong expected, ulong actual, string message, params object[] args)
		{
			return this.ExecuteTest(() => Assert.AreNotEqual(expected, actual, message, args), message, args);
		}

		#endregion

		#region Same / Not Same

		/// <summary>
		/// Asserts that two objects refer to the same object. If they are not the
		/// same an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="expected">The expected.</param>
		/// <param name="actual">The actual.</param>
		public TestResult AreSame(object expected, object actual)
		{
			return this.ExecuteTest(() => Assert.AreSame(expected, actual));
		}

		/// <summary>
		/// Asserts that two objects refer to the same object. If they are not the
		/// same an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="expected">The expected.</param>
		/// <param name="actual">The actual.</param>
		/// <param name="message">The message to display in case of failure.</param>
		public TestResult AreSame(object expected, object actual, string message)
		{
			return this.ExecuteTest(() => Assert.AreSame(expected, actual, message), message);
		}

		/// <summary>
		/// Asserts that two objects refer to the same object. If they are not the
		/// same an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="expected">The expected.</param>
		/// <param name="actual">The actual.</param>
		/// <param name="message">The message to display in case of failure.</param>
		/// <param name="args">Array of objects to be used in formatting the message.</param>
		public TestResult AreSame(object expected, object actual, string message, params object[] args)
		{
			return this.ExecuteTest(() => Assert.AreSame(expected, actual, message, args), message, args);
		}

		/// <summary>
		///     Asserts that two objects do not refer to the same object. If they are the
		///     same an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="expected">The expected object.</param>
		/// <param name="actual">The actual object.</param>
		public TestResult AreNotSame(object expected, object actual)
		{
			return this.ExecuteTest(() => Assert.AreNotSame(expected, actual));
		}

		/// <summary>
		/// Asserts that two objects do not refer to the same object. If they are the
		/// same an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="expected">The expected object.</param>
		/// <param name="actual">The actual object.</param>
		/// <param name="message">The message to display in case of failure.</param>
		public TestResult AreNotSame(object expected, object actual, string message)
		{
			return this.ExecuteTest(() => Assert.AreNotSame(expected, actual, message), message);
		}

		/// <summary>
		/// Asserts that two objects do not refer to the same object. If they are the
		/// same an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="expected">The expected object.</param>
		/// <param name="actual">The actual object.</param>
		/// <param name="message">The message to display in case of failure.</param>
		/// <param name="args">Array of objects to be used in formatting the message.</param>
		public TestResult AreNotSame(object expected, object actual, string message, params object[] args)
		{
			return this.ExecuteTest(() => Assert.AreNotSame(expected, actual, message, args), message, args);
		}

		#endregion

		#region Null / Not Null - Object

		/// <summary>
		/// Verifies that the object that is passed in is not equal to null If the object
		/// is null then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="anObject">The object that is to be tested.</param>
		public TestResult IsNotNull(object anObject)
		{
			return this.ExecuteTest(() => Assert.IsNotNull(anObject));
		}

		/// <summary>
		/// Verifies that the object that is passed in is not equal to null If the object
		/// is null then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="anObject">The object that is to be tested.</param>
		/// <param name="message">The message to display in case of failure.</param>
		public TestResult IsNotNull(object anObject, string message)
		{
			return this.ExecuteTest(() => Assert.IsNotNull(anObject, message), message);
		}

		/// <summary>
		/// Verifies that the object that is passed in is not equal to null If the object
		/// is null then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="anObject">The object that is to be tested.</param>
		/// <param name="message">The message to display in case of failure.</param>
		/// <param name="args">Array of objects to be used in formatting the message.</param>
		public TestResult IsNotNull(object anObject, string message, params object[] args)
		{
			return this.ExecuteTest(() => Assert.IsNotNull(anObject, message, args), message, args);
		}

		/// <summary>
		/// Verifies that the object that is passed in is equal to null If the object
		/// is not null then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="anObject">The object that is to be tested.</param>
		public TestResult IsNull(object anObject)
		{
			return this.ExecuteTest(() => Assert.IsNull(anObject));
		}

		/// <summary>
		/// Verifies that the object that is passed in is equal to null If the object
		/// is not null then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="anObject">The object that is to be tested.</param>
		/// <param name="message">The message to display in case of failure.</param>
		public TestResult IsNull(object anObject, string message)
		{
			return this.ExecuteTest(() => Assert.IsNull(anObject, message), message);
		}

		/// <summary>
		/// Verifies that the object that is passed in is equal to null If the object
		/// is not null then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="anObject">The object that is to be tested.</param>
		/// <param name="message">The message to display in case of failure.</param>
		/// <param name="args">Array of objects to be used in formatting the message.</param>
		public TestResult IsNull(object anObject, string message, params object[] args)
		{
			return this.ExecuteTest(() => Assert.IsNull(anObject, message, args), message, args);
		}

		/// <summary>
		/// Assert that a string is not null or empty.
		/// </summary>
		/// <param name="aString">The string that is to be tested.</param>
		public TestResult IsNotNull(string aString)
		{
			return this.ExecuteTest(() => Assert.IsNotNull(aString));
		}

		/// <summary>
		/// Assert that a string is not null or empty.
		/// </summary>
		/// <param name="aString">The string that is to be tested.</param>
		/// <param name="message">The message to display in case of failure.</param>
		public TestResult IsNotNull(string aString, string message)
		{
			return this.ExecuteTest(() => Assert.IsNotNull(aString, message), message);
		}

		/// <summary>
		/// Assert that a string is not null or empty.
		/// </summary>
		/// <param name="aString">The string that is to be tested.</param>
		/// <param name="message">The message to display in case of failure.</param>
		/// <param name="args">Array of objects to be used in formatting the message.</param>
		public TestResult IsNotNull(string aString, string message, params object[] args)
		{
			return this.ExecuteTest(() => Assert.IsNotNull(aString, message, args), message, args);
		}

		/// <summary>
		/// Assert that a string is either null or equal to string.Empty.
		/// </summary>
		/// <param name="aString">The string to be tested.</param>
		public TestResult IsNullOrEmpty(string aString)
		{
			return this.ExecuteTest(() => Assert.IsNullOrEmpty(aString));
		}

		/// <summary>
		/// Assert that a string is either null or equal to string.Empty.
		/// </summary>
		/// <param name="aString">The string to be tested.</param>
		/// <param name="message">The message to display in case of failure.</param>
		public TestResult IsNullOrEmpty(string aString, string message)
		{
			return this.ExecuteTest(() => Assert.IsNullOrEmpty(aString, message), message);
		}

		/// <summary>
		/// Assert that a string is either null or equal to string.Empty.
		/// </summary>
		/// <param name="aString">The string to be tested.</param>
		/// <param name="message">The message to display in case of failure.</param>
		/// <param name="args">Array of objects to be used in formatting the message.</param>
		public TestResult IsNullOrEmpty(string aString, string message, params object[] args)
		{
			return this.ExecuteTest(() => Assert.IsNullOrEmpty(aString, message, args), message, args);
		}

		#endregion

		// TODO: everything under this todo

		#region Catch / Swallowing Exceptions

		/// <summary>
		/// Verifies that a delegate throws an exception when called and returns it.
		/// </summary>
		/// <param name="code">A TestDelegate.</param>
		/// <returns></returns>
		public Exception Catch(TestDelegate code)
		{
			return Assert.Catch(code);
		}

		/// <summary>
		/// Verifies that a delegate does not throw an exception when called and returns it.
		/// </summary>
		/// <param name="code">A TestDelegate.</param>
		/// <returns></returns>
		public void DoesNotThrow(TestDelegate code)
		{
			Assert.DoesNotThrow(code);
		}

		/// <summary>
		/// Verifies that a delegate throws an exception of a certain Type or one derived
		/// from it when called and returns it.
		/// </summary>
		/// <typeparam name="T">The expected Exception Type.</typeparam>
		/// <param name="code">A TestDelegate.</param>
		/// <returns></returns>
		public T Catch<T>(TestDelegate code) where T : Exception
		{
			return Assert.Catch<T>(code);
		}

		/// <summary>
		/// Verifies that a delegate throws an exception when called and returns it.
		/// </summary>
		/// <param name="code">A TestDelegate.</param>
		/// <param name="message">The message that will be displayed on failure.</param>
		/// <returns></returns>
		public Exception Catch(TestDelegate code, string message)
		{
			return Assert.Catch(code, message);
		}

		/// <summary>
		/// Verifies that a delegate throws an exception of a certain Type or one derived
		/// from it when called and returns it.
		/// </summary>
		/// <typeparam name="T">The expected Exception Type.</typeparam>
		/// <param name="code">A TestDelegate.</param>
		/// <param name="message">The message that will be displayed on failure.</param>
		/// <returns></returns>
		public T Catch<T>(TestDelegate code, string message) where T : Exception
		{
			return Assert.Catch<T>(code, message);
		}

		/// <summary>
		///     Verifies that a delegate throws an exception of a certain Type or one derived
		///     from it when called and returns it.
		/// </summary>
		/// <param name="expectedExceptionType">The expected Exception Type.</param>
		/// <param name="code">A TestDelegate.</param>
		/// <returns></returns>
		public Exception Catch(Type expectedExceptionType, TestDelegate code)
		{
			return Assert.Catch(expectedExceptionType, code);
		}

		/// <summary>
		/// Verifies that a delegate throws an exception when called and returns it.
		/// </summary>
		/// <param name="code">A TestDelegate.</param>
		/// <param name="message">The message that will be displayed on failure.</param>
		/// <param name="args">Arguments to be used in formatting the message.</param>
		/// <returns></returns>
		public Exception Catch(TestDelegate code, string message, params object[] args)
		{
			return Assert.Catch(code, message, args);
		}

		/// <summary>
		/// Verifies that a delegate throws an exception when called and returns it.
		/// </summary>
		/// <typeparam name="T">The expected Exception Type.</typeparam>
		/// <param name="code">A TestDelegate.</param>
		/// <param name="message">The message that will be displayed on failure.</param>
		/// <param name="args">Arguments to be used in formatting the message.</param>
		/// <returns></returns>
		public T Catch<T>(TestDelegate code, string message, params object[] args)
			where T : Exception
		{
			return Assert.Catch<T>(code, message, args);
		}

		/// <summary>
		/// Verifies that a delegate throws an exception of a certain Type or one derived
		/// from it when called and returns it.
		/// </summary>
		/// <param name="expectedExceptionType">The expected Exception Type.</param>
		/// <param name="code">A TestDelegate.</param>
		/// <param name="message">The message that will be displayed on failure.</param>
		/// <returns></returns>
		public Exception Catch(Type expectedExceptionType, TestDelegate code, string message)
		{
			return Assert.Catch(expectedExceptionType, code, message);
		}

		/// <summary>
		/// Verifies that a delegate throws an exception of a certain Type or one derived
		/// from it when called and returns it.
		/// </summary>
		/// <param name="expectedExceptionType">The expected Exception Type.</param>
		/// <param name="code">A TestDelegate.</param>
		/// <param name="message">The message that will be displayed on failure.</param>
		/// <param name="args">Arguments to be used in formatting the message.</param>
		/// <returns></returns>
		public Exception Catch(Type expectedExceptionType, TestDelegate code, string message, params object[] args)
		{
			return Assert.Catch(expectedExceptionType, code, message, args);
		}

		/// <summary>
		/// Verifies that a delegate does not throw an exception.
		/// </summary>
		/// <param name="code">A TestSnippet delegate.</param>
		/// <param name="message">The message that will be displayed on failure.</param>
		public void DoesNotThrow(TestDelegate code, string message)
		{
			Assert.DoesNotThrow(code, message);
		}

		/// <summary>
		/// Verifies that a delegate does not throw an exception.
		/// </summary>
		/// <param name="code">A TestSnippet delegate.</param>
		/// <param name="message">The message that will be displayed on failure.</param>
		/// <param name="args">Arguments to be used in formatting the message.</param>
		public void DoesNotThrow(TestDelegate code, string message, params object[] args)
		{
			Assert.DoesNotThrow(code, message, args);
		}

		#endregion

		#region Contains / Does not Contain

		/// <summary>
		/// Asserts that an object is contained in a list.
		/// </summary>
		/// <param name="expected">The expected object.</param>
		/// <param name="actual">The list to be examined.</param>
		public void Contains(object expected, ICollection actual)
		{
			Assert.Contains(expected, actual);
		}

		/// <summary>
		/// Asserts that an object is contained in a list.
		/// </summary>
		/// <param name="expected">The expected object.</param>
		/// <param name="actual">The list to be examined.</param>
		/// <param name="message">The message to display in case of failure.</param>
		public void Contains(object expected, ICollection actual, string message)
		{
			Assert.Contains(expected, actual, message);
		}

		/// <summary>
		/// Asserts that an object is contained in a list.
		/// </summary>
		/// <param name="expected">The expected object.</param>
		/// <param name="actual">The list to be examined.</param>
		/// <param name="message">The message to display in case of failure.</param>
		/// <param name="args">Array of objects to be used in formatting the message.</param>
		public void Contains(object expected, ICollection actual, string message, params object[] args)
		{
			Assert.Contains(expected, actual, message, args);
		}

		#endregion

		#region Failures

		/// <summary>
		/// Throws an <see cref="AssertionException"/> with the message that is passed in.
		/// This is used by the other Assert functions.
		/// </summary>
		public void Fail()
		{
			Assert.Fail();
		}

		/// <summary>
		/// Throws an <see cref="AssertionException"/> with the message that is passed in.
		/// This is used by the other Assert functions.
		/// </summary>
		/// <param name="message">The message to initialize the <see cref="AssertionException"/> with.</param>
		public void Fail(string message)
		{
			Assert.Fail(message);
		}

		/// <summary>
		/// Throws an <see cref="AssertionException"/> with the message that is passed in.
		/// This is used by the other Assert functions.
		/// </summary>
		/// <param name="message">The message to initialize the <see cref="AssertionException"/> with.</param>
		/// <param name="args">Arguments to be used in formatting the message.</param>
		public void Fail(string message, params object[] args)
		{
			Assert.Fail(message, args);
		}

		#endregion

		#region Greater/Less or Equal

		/// <summary>
		///     Verifies that the first value is less than the second value. If it is
		///     not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="arg1">The first value, expected to be less.</param>
		/// <param name="arg2">The second value, expected to be less.</param>
		public void Greater(decimal arg1, decimal arg2)
		{
			Assert.Greater(arg1, arg2);
		}

		/// <summary>
		///     Verifies that the first value is less than the second value. If it is
		///     not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="arg1">The first value, expected to be less.</param>
		/// <param name="arg2">The second value, expected to be less.</param>
		public void Greater(double arg1, double arg2)
		{
			Assert.Greater(arg1, arg2);
		}

		/// <summary>
		///     Verifies that the first value is less than the second value. If it is
		///     not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="arg1">The first value, expected to be less.</param>
		/// <param name="arg2">The second value, expected to be less.</param>
		public void Greater(float arg1, float arg2)
		{
			Assert.Greater(arg1, arg2);
		}

		/// <summary>
		///     Verifies that the first value is less than the second value. If it is
		///     not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="arg1">The first value, expected to be less.</param>
		/// <param name="arg2">The second value, expected to be less.</param>
		public void Greater(IComparable arg1, IComparable arg2)
		{
			Assert.Greater(arg1, arg2);
		}

		/// <summary>
		///     Verifies that the first value is less than the second value. If it is
		///     not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="arg1">The first value, expected to be less.</param>
		/// <param name="arg2">The second value, expected to be less.</param>
		public void Greater(int arg1, int arg2)
		{
			Assert.Greater(arg1, arg2);
		}

		/// <summary>
		///     Verifies that the first value is less than the second value. If it is
		///     not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="arg1">The first value, expected to be less.</param>
		/// <param name="arg2">The second value, expected to be less.</param>
		public void Greater(long arg1, long arg2)
		{
			Assert.Greater(arg1, arg2);
		}

		/// <summary>
		///     Verifies that the first value is less than the second value. If it is
		///     not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="arg1">The first value, expected to be less.</param>
		/// <param name="arg2">The second value, expected to be less.</param>
		public void Greater(uint arg1, uint arg2)
		{
			Assert.Greater(arg1, arg2);
		}

		/// <summary>
		///     Verifies that the first value is less than the second value. If it is
		///     not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="arg1">The first value, expected to be less.</param>
		/// <param name="arg2">The second value, expected to be less.</param>
		public void Greater(ulong arg1, ulong arg2)
		{
			Assert.Greater(arg1, arg2);
		}

		/// <summary>
		/// Verifies that the first value is less than the second value. If it is
		/// not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="arg1">The first value, expected to be less.</param>
		/// <param name="arg2">The second value, expected to be less.</param>
		/// <param name="message">The message to display in case of failure.</param>
		public void Greater(decimal arg1, decimal arg2, string message)
		{
			Assert.Greater(arg1, arg2, message);
		}

		/// <summary>
		/// Verifies that the first value is less than the second value. If it is
		/// not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="arg1">The first value, expected to be less.</param>
		/// <param name="arg2">The second value, expected to be less.</param>
		/// <param name="message">The message to display in case of failure.</param>
		public void Greater(double arg1, double arg2, string message)
		{
			Assert.Greater(arg1, arg2, message);
		}

		/// <summary>
		/// Verifies that the first value is less than the second value. If it is
		/// not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="arg1">The first value, expected to be less.</param>
		/// <param name="arg2">The second value, expected to be less.</param>
		/// <param name="message">The message to display in case of failure.</param>
		public void Greater(float arg1, float arg2, string message)
		{
			Assert.Greater(arg1, arg2, message);
		}

		/// <summary>
		/// Verifies that the first value is less than the second value. If it is
		/// not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="arg1">The first value, expected to be less.</param>
		/// <param name="arg2">The second value, expected to be less.</param>
		/// <param name="message">The message to display in case of failure.</param>
		public void Greater(IComparable arg1, IComparable arg2, string message)
		{
			Assert.Greater(arg1, arg2, message);
		}

		/// <summary>
		/// Verifies that the first value is less than the second value. If it is
		/// not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="arg1">The first value, expected to be less.</param>
		/// <param name="arg2">The second value, expected to be less.</param>
		/// <param name="message">The message to display in case of failure.</param>
		public void Greater(int arg1, int arg2, string message)
		{
			Assert.Greater(arg1, arg2, message);
		}

		/// <summary>
		/// Verifies that the first value is less than the second value. If it is
		/// not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="arg1">The first value, expected to be less.</param>
		/// <param name="arg2">The second value, expected to be less.</param>
		/// <param name="message">The message to display in case of failure.</param>
		public void Greater(long arg1, long arg2, string message)
		{
			Assert.Greater(arg1, arg2, message);
		}

		/// <summary>
		/// Verifies that the first value is less than the second value. If it is
		/// not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="arg1">The first value, expected to be less.</param>
		/// <param name="arg2">The second value, expected to be less.</param>
		/// <param name="message">The message to display in case of failure.</param>
		public void Greater(uint arg1, uint arg2, string message)
		{
			Assert.Greater(arg1, arg2, message);
		}

		/// <summary>
		/// Verifies that the first value is less than the second value. If it is
		/// not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="arg1">The first value, expected to be less.</param>
		/// <param name="arg2">The second value, expected to be less.</param>
		/// <param name="message">The message to display in case of failure.</param>
		public void Greater(ulong arg1, ulong arg2, string message)
		{
			Assert.Greater(arg1, arg2, message);
		}

		/// <summary>
		/// Verifies that the first value is less than the second value. If it is
		/// not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="arg1">The first value, expected to be less.</param>
		/// <param name="arg2">The second value, expected to be less.</param>
		/// <param name="message">The message to display in case of failure.</param>
		/// <param name="args">Array of objects to be used in formatting the message.</param>
		public void Greater(decimal arg1, decimal arg2, string message, params object[] args)
		{
			Assert.Greater(arg1, arg2, message, args);
		}

		/// <summary>
		/// Verifies that the first value is less than the second value. If it is
		/// not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="arg1">The first value, expected to be less.</param>
		/// <param name="arg2">The second value, expected to be less.</param>
		/// <param name="message">The message to display in case of failure.</param>
		/// <param name="args">Array of objects to be used in formatting the message.</param>
		public void Greater(double arg1, double arg2, string message, params object[] args)
		{
			Assert.Greater(arg1, arg2, message, args);
		}

		/// <summary>
		/// Verifies that the first value is less than the second value. If it is
		/// not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="arg1">The first value, expected to be less.</param>
		/// <param name="arg2">The second value, expected to be less.</param>
		/// <param name="message">The message to display in case of failure.</param>
		/// <param name="args">Array of objects to be used in formatting the message.</param>
		public void Greater(float arg1, float arg2, string message, params object[] args)
		{
			Assert.Greater(arg1, arg2, message, args);
		}

		/// <summary>
		/// Verifies that the first value is less than the second value. If it is
		/// not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="arg1">The first value, expected to be less.</param>
		/// <param name="arg2">The second value, expected to be less.</param>
		/// <param name="message">The message to display in case of failure.</param>
		/// <param name="args">Array of objects to be used in formatting the message.</param>
		public void Greater(IComparable arg1, IComparable arg2, string message, params object[] args)
		{
			Assert.Greater(arg1, arg2, message, args);
		}

		/// <summary>
		/// Verifies that the first value is less than the second value. If it is
		/// not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="arg1">The first value, expected to be less.</param>
		/// <param name="arg2">The second value, expected to be less.</param>
		/// <param name="message">The message to display in case of failure.</param>
		/// <param name="args">Array of objects to be used in formatting the message.</param>
		public void Greater(int arg1, int arg2, string message, params object[] args)
		{
			Assert.Greater(arg1, arg2, message, args);
		}

		/// <summary>
		/// Verifies that the first value is less than the second value. If it is
		/// not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="arg1">The first value, expected to be less.</param>
		/// <param name="arg2">The second value, expected to be less.</param>
		/// <param name="message">The message to display in case of failure.</param>
		/// <param name="args">Array of objects to be used in formatting the message.</param>
		public void Greater(long arg1, long arg2, string message, params object[] args)
		{
			Assert.Greater(arg1, arg2, message, args);
		}

		/// <summary>
		/// Verifies that the first value is less than the second value. If it is
		/// not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="arg1">The first value, expected to be less.</param>
		/// <param name="arg2">The second value, expected to be less.</param>
		/// <param name="message">The message to display in case of failure.</param>
		/// <param name="args">Array of objects to be used in formatting the message.</param>
		public void Greater(uint arg1, uint arg2, string message, params object[] args)
		{
			Assert.Greater(arg1, arg2, message, args);
		}

		/// <summary>
		/// Verifies that the first value is less than the second value. If it is
		/// not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="arg1">The first value, expected to be less.</param>
		/// <param name="arg2">The second value, expected to be less.</param>
		/// <param name="message">The message to display in case of failure.</param>
		/// <param name="args">Array of objects to be used in formatting the message.</param>
		public void Greater(ulong arg1, ulong arg2, string message, params object[] args)
		{
			Assert.Greater(arg1, arg2, message, args);
		}

		/// <summary>
		/// Verifies that the first value is less than or equal to the second value. If it is
		/// not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="arg1">The first value, expected to be less than or equal to.</param>
		/// <param name="arg2">The second value, expected to be less than or equal to.</param>
		public void GreaterOrEqual(decimal arg1, decimal arg2)
		{
			Assert.GreaterOrEqual(arg1, arg2);
		}

		/// <summary>
		/// Verifies that the first value is less than or equal to the second value. If it is
		/// not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="arg1">The first value, expected to be less than or equal to.</param>
		/// <param name="arg2">The second value, expected to be less than or equal to.</param>
		public void GreaterOrEqual(double arg1, double arg2)
		{
			Assert.GreaterOrEqual(arg1, arg2);
		}

		/// <summary>
		/// Verifies that the first value is less than or equal to the second value. If it is
		/// not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="arg1">The first value, expected to be less than or equal to.</param>
		/// <param name="arg2">The second value, expected to be less than or equal to.</param>
		public void GreaterOrEqual(float arg1, float arg2)
		{
			Assert.GreaterOrEqual(arg1, arg2);
		}

		/// <summary>
		/// Verifies that the first value is less than or equal to the second value. If it is
		/// not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="arg1">The first value, expected to be less than or equal to.</param>
		/// <param name="arg2">The second value, expected to be less than or equal to.</param>
		public void GreaterOrEqual(IComparable arg1, IComparable arg2)
		{
			Assert.GreaterOrEqual(arg1, arg2);
		}

		/// <summary>
		/// Verifies that the first value is less than or equal to the second value. If it is
		/// not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="arg1">The first value, expected to be less than or equal to.</param>
		/// <param name="arg2">The second value, expected to be less than or equal to.</param>
		public void GreaterOrEqual(int arg1, int arg2)
		{
			Assert.GreaterOrEqual(arg1, arg2);
		}

		/// <summary>
		/// Verifies that the first value is less than or equal to the second value. If it is
		/// not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="arg1">The first value, expected to be less than or equal to.</param>
		/// <param name="arg2">The second value, expected to be less than or equal to.</param>
		public void GreaterOrEqual(long arg1, long arg2)
		{
			Assert.GreaterOrEqual(arg1, arg2);
		}

		/// <summary>
		/// Verifies that the first value is less than or equal to the second value. If it is
		/// not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="arg1">The first value, expected to be less than or equal to.</param>
		/// <param name="arg2">The second value, expected to be less than or equal to.</param>
		public void GreaterOrEqual(uint arg1, uint arg2)
		{
			Assert.GreaterOrEqual(arg1, arg2);
		}

		/// <summary>
		/// Verifies that the first value is less than or equal to the second value. If it is
		/// not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="arg1">The first value, expected to be less than or equal to.</param>
		/// <param name="arg2">The second value, expected to be less than or equal to.</param>
		public void GreaterOrEqual(ulong arg1, ulong arg2)
		{
			Assert.GreaterOrEqual(arg1, arg2);
		}

		/// <summary>
		/// Verifies that the first value is less than or equal to the second value. If it is
		/// not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="arg1">The first value, expected to be less than or equal to.</param>
		/// <param name="arg2">The second value, expected to be less than or equal to.</param>
		/// <param name="message">The message to display in case of failure.</param>
		public void GreaterOrEqual(decimal arg1, decimal arg2, string message)
		{
			Assert.GreaterOrEqual(arg1, arg2, message);
		}

		/// <summary>
		/// Verifies that the first value is less than or equal to the second value. If it is
		/// not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="arg1">The first value, expected to be less than or equal to.</param>
		/// <param name="arg2">The second value, expected to be less than or equal to.</param>
		/// <param name="message">The message to display in case of failure.</param>
		public void GreaterOrEqual(double arg1, double arg2, string message)
		{
			Assert.GreaterOrEqual(arg1, arg2, message);
		}

		/// <summary>
		/// Verifies that the first value is less than or equal to the second value. If it is
		/// not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="arg1">The first value, expected to be less than or equal to.</param>
		/// <param name="arg2">The second value, expected to be less than or equal to.</param>
		/// <param name="message">The message to display in case of failure.</param>
		public void GreaterOrEqual(float arg1, float arg2, string message)
		{
			Assert.GreaterOrEqual(arg1, arg2, message);
		}

		/// <summary>
		/// Verifies that the first value is less than or equal to the second value. If it is
		/// not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="arg1">The first value, expected to be less than or equal to.</param>
		/// <param name="arg2">The second value, expected to be less than or equal to.</param>
		/// <param name="message">The message to display in case of failure.</param>
		public void GreaterOrEqual(IComparable arg1, IComparable arg2, string message)
		{
			Assert.GreaterOrEqual(arg1, arg2, message);
		}

		/// <summary>
		/// Verifies that the first value is less than or equal to the second value. If it is
		/// not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="arg1">The first value, expected to be less than or equal to.</param>
		/// <param name="arg2">The second value, expected to be less than or equal to.</param>
		/// <param name="message">The message to display in case of failure.</param>
		public void GreaterOrEqual(int arg1, int arg2, string message)
		{
			Assert.GreaterOrEqual(arg1, arg2, message);
		}

		/// <summary>
		/// Verifies that the first value is less than or equal to the second value. If it is
		/// not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="arg1">The first value, expected to be less than or equal to.</param>
		/// <param name="arg2">The second value, expected to be less than or equal to.</param>
		/// <param name="message">The message to display in case of failure.</param>
		public void GreaterOrEqual(long arg1, long arg2, string message)
		{
			Assert.GreaterOrEqual(arg1, arg2, message);
		}

		/// <summary>
		/// Verifies that the first value is less than or equal to the second value. If it is
		/// not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="arg1">The first value, expected to be less than or equal to.</param>
		/// <param name="arg2">The second value, expected to be less than or equal to.</param>
		/// <param name="message">The message to display in case of failure.</param>
		public void GreaterOrEqual(uint arg1, uint arg2, string message)
		{
			Assert.GreaterOrEqual(arg1, arg2, message);
		}

		/// <summary>
		/// Verifies that the first value is less than or equal to the second value. If it is
		/// not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="arg1">The first value, expected to be less than or equal to.</param>
		/// <param name="arg2">The second value, expected to be less than or equal to.</param>
		/// <param name="message">The message to display in case of failure.</param>
		public void GreaterOrEqual(ulong arg1, ulong arg2, string message)
		{
			Assert.GreaterOrEqual(arg1, arg2, message);
		}

		/// <summary>
		/// Verifies that the first value is less than or equal to the second value. If it is
		/// not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="arg1">The first value, expected to be less than or equal to.</param>
		/// <param name="arg2">The second value, expected to be less than or equal to.</param>
		/// <param name="message">The message to display in case of failure.</param>
		/// <param name="args">Array of objects to be used in formatting the message.</param>
		public void GreaterOrEqual(decimal arg1, decimal arg2, string message, params object[] args)
		{
			Assert.GreaterOrEqual(arg1, arg2, message, args);
		}

		/// <summary>
		/// Verifies that the first value is less than or equal to the second value. If it is
		/// not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="arg1">The first value, expected to be less than or equal to.</param>
		/// <param name="arg2">The second value, expected to be less than or equal to.</param>
		/// <param name="message">The message to display in case of failure.</param>
		/// <param name="args">Array of objects to be used in formatting the message.</param>
		public void GreaterOrEqual(double arg1, double arg2, string message, params object[] args)
		{
			Assert.GreaterOrEqual(arg1, arg2, message, args);
		}

		/// <summary>
		/// Verifies that the first value is less than or equal to the second value. If it is
		/// not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="arg1">The first value, expected to be less than or equal to.</param>
		/// <param name="arg2">The second value, expected to be less than or equal to.</param>
		/// <param name="message">The message to display in case of failure.</param>
		/// <param name="args">Array of objects to be used in formatting the message.</param>
		public void GreaterOrEqual(float arg1, float arg2, string message, params object[] args)
		{
			Assert.GreaterOrEqual(arg1, arg2, message, args);
		}

		/// <summary>
		/// Verifies that the first value is less than or equal to the second value. If it is
		/// not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="arg1">The first value, expected to be less than or equal to.</param>
		/// <param name="arg2">The second value, expected to be less than or equal to.</param>
		/// <param name="message">The message to display in case of failure.</param>
		/// <param name="args">Array of objects to be used in formatting the message.</param>
		public void GreaterOrEqual(IComparable arg1, IComparable arg2, string message, params object[] args)
		{
			Assert.GreaterOrEqual(arg1, arg2, message, args);
		}

		/// <summary>
		/// Verifies that the first value is less than or equal to the second value. If it is
		/// not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="arg1">The first value, expected to be less than or equal to.</param>
		/// <param name="arg2">The second value, expected to be less than or equal to.</param>
		/// <param name="message">The message to display in case of failure.</param>
		/// <param name="args">Array of objects to be used in formatting the message.</param>
		public void GreaterOrEqual(int arg1, int arg2, string message, params object[] args)
		{
			Assert.GreaterOrEqual(arg1, arg2, message, args);
		}

		/// <summary>
		/// Verifies that the first value is less than or equal to the second value. If it is
		/// not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="arg1">The first value, expected to be less than or equal to.</param>
		/// <param name="arg2">The second value, expected to be less than or equal to.</param>
		/// <param name="message">The message to display in case of failure.</param>
		/// <param name="args">Array of objects to be used in formatting the message.</param>
		public void GreaterOrEqual(long arg1, long arg2, string message, params object[] args)
		{
			Assert.GreaterOrEqual(arg1, arg2, message, args);
		}

		/// <summary>
		/// Verifies that the first value is less than or equal to the second value. If it is
		/// not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="arg1">The first value, expected to be less than or equal to.</param>
		/// <param name="arg2">The second value, expected to be less than or equal to.</param>
		/// <param name="message">The message to display in case of failure.</param>
		/// <param name="args">Array of objects to be used in formatting the message.</param>
		public void GreaterOrEqual(uint arg1, uint arg2, string message, params object[] args)
		{
			Assert.GreaterOrEqual(arg1, arg2, message, args);
		}

		/// <summary>
		/// Verifies that the first value is less than or equal to the second value. If it is
		/// not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="arg1">The first value, expected to be less than or equal to.</param>
		/// <param name="arg2">The second value, expected to be less than or equal to.</param>
		/// <param name="message">The message to display in case of failure.</param>
		/// <param name="args">Array of objects to be used in formatting the message.</param>
		public void GreaterOrEqual(ulong arg1, ulong arg2, string message, params object[] args)
		{
			Assert.GreaterOrEqual(arg1, arg2, message, args);
		}

		// HERE!!!

		/// <summary>
		///     Verifies that the first value is less than the second value. If it is
		///     not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="arg1">The first value, expected to be less.</param>
		/// <param name="arg2">The second value, expected to be less.</param>
		public void Less(decimal arg1, decimal arg2)
		{
			Assert.Less(arg1, arg2);
		}

		/// <summary>
		///     Verifies that the first value is less than the second value. If it is
		///     not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="arg1">The first value, expected to be less.</param>
		/// <param name="arg2">The second value, expected to be less.</param>
		public void Less(double arg1, double arg2)
		{
			Assert.Less(arg1, arg2);
		}

		/// <summary>
		///     Verifies that the first value is less than the second value. If it is
		///     not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="arg1">The first value, expected to be less.</param>
		/// <param name="arg2">The second value, expected to be less.</param>
		public void Less(float arg1, float arg2)
		{
			Assert.Less(arg1, arg2);
		}

		/// <summary>
		///     Verifies that the first value is less than the second value. If it is
		///     not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="arg1">The first value, expected to be less.</param>
		/// <param name="arg2">The second value, expected to be less.</param>
		public void Less(IComparable arg1, IComparable arg2)
		{
			Assert.Less(arg1, arg2);
		}

		/// <summary>
		///     Verifies that the first value is less than the second value. If it is
		///     not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="arg1">The first value, expected to be less.</param>
		/// <param name="arg2">The second value, expected to be less.</param>
		public void Less(int arg1, int arg2)
		{
			Assert.Less(arg1, arg2);
		}

		/// <summary>
		///     Verifies that the first value is less than the second value. If it is
		///     not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="arg1">The first value, expected to be less.</param>
		/// <param name="arg2">The second value, expected to be less.</param>
		public void Less(long arg1, long arg2)
		{
			Assert.Less(arg1, arg2);
		}

		/// <summary>
		///     Verifies that the first value is less than the second value. If it is
		///     not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="arg1">The first value, expected to be less.</param>
		/// <param name="arg2">The second value, expected to be less.</param>
		public void Less(uint arg1, uint arg2)
		{
			Assert.Less(arg1, arg2);
		}

		/// <summary>
		///     Verifies that the first value is less than the second value. If it is
		///     not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="arg1">The first value, expected to be less.</param>
		/// <param name="arg2">The second value, expected to be less.</param>
		public void Less(ulong arg1, ulong arg2)
		{
			Assert.Less(arg1, arg2);
		}

		/// <summary>
		/// Verifies that the first value is less than the second value. If it is
		/// not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="arg1">The first value, expected to be less.</param>
		/// <param name="arg2">The second value, expected to be less.</param>
		/// <param name="message">The message to display in case of failure.</param>
		public void Less(decimal arg1, decimal arg2, string message)
		{
			Assert.Less(arg1, arg2, message);
		}

		/// <summary>
		/// Verifies that the first value is less than the second value. If it is
		/// not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="arg1">The first value, expected to be less.</param>
		/// <param name="arg2">The second value, expected to be less.</param>
		/// <param name="message">The message to display in case of failure.</param>
		public void Less(double arg1, double arg2, string message)
		{
			Assert.Less(arg1, arg2, message);
		}

		/// <summary>
		/// Verifies that the first value is less than the second value. If it is
		/// not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="arg1">The first value, expected to be less.</param>
		/// <param name="arg2">The second value, expected to be less.</param>
		/// <param name="message">The message to display in case of failure.</param>
		public void Less(float arg1, float arg2, string message)
		{
			Assert.Less(arg1, arg2, message);
		}

		/// <summary>
		/// Verifies that the first value is less than the second value. If it is
		/// not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="arg1">The first value, expected to be less.</param>
		/// <param name="arg2">The second value, expected to be less.</param>
		/// <param name="message">The message to display in case of failure.</param>
		public void Less(IComparable arg1, IComparable arg2, string message)
		{
			Assert.Less(arg1, arg2, message);
		}

		/// <summary>
		/// Verifies that the first value is less than the second value. If it is
		/// not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="arg1">The first value, expected to be less.</param>
		/// <param name="arg2">The second value, expected to be less.</param>
		/// <param name="message">The message to display in case of failure.</param>
		public void Less(int arg1, int arg2, string message)
		{
			Assert.Less(arg1, arg2, message);
		}

		/// <summary>
		/// Verifies that the first value is less than the second value. If it is
		/// not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="arg1">The first value, expected to be less.</param>
		/// <param name="arg2">The second value, expected to be less.</param>
		/// <param name="message">The message to display in case of failure.</param>
		public void Less(long arg1, long arg2, string message)
		{
			Assert.Less(arg1, arg2, message);
		}

		/// <summary>
		/// Verifies that the first value is less than the second value. If it is
		/// not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="arg1">The first value, expected to be less.</param>
		/// <param name="arg2">The second value, expected to be less.</param>
		/// <param name="message">The message to display in case of failure.</param>
		public void Less(uint arg1, uint arg2, string message)
		{
			Assert.Less(arg1, arg2, message);
		}

		/// <summary>
		/// Verifies that the first value is less than the second value. If it is
		/// not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="arg1">The first value, expected to be less.</param>
		/// <param name="arg2">The second value, expected to be less.</param>
		/// <param name="message">The message to display in case of failure.</param>
		public void Less(ulong arg1, ulong arg2, string message)
		{
			Assert.Less(arg1, arg2, message);
		}

		/// <summary>
		/// Verifies that the first value is less than the second value. If it is
		/// not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="arg1">The first value, expected to be less.</param>
		/// <param name="arg2">The second value, expected to be less.</param>
		/// <param name="message">The message to display in case of failure.</param>
		/// <param name="args">Array of objects to be used in formatting the message.</param>
		public void Less(decimal arg1, decimal arg2, string message, params object[] args)
		{
			Assert.Less(arg1, arg2, message, args);
		}

		/// <summary>
		/// Verifies that the first value is less than the second value. If it is
		/// not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="arg1">The first value, expected to be less.</param>
		/// <param name="arg2">The second value, expected to be less.</param>
		/// <param name="message">The message to display in case of failure.</param>
		/// <param name="args">Array of objects to be used in formatting the message.</param>
		public void Less(double arg1, double arg2, string message, params object[] args)
		{
			Assert.Less(arg1, arg2, message, args);
		}

		/// <summary>
		/// Verifies that the first value is less than the second value. If it is
		/// not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="arg1">The first value, expected to be less.</param>
		/// <param name="arg2">The second value, expected to be less.</param>
		/// <param name="message">The message to display in case of failure.</param>
		/// <param name="args">Array of objects to be used in formatting the message.</param>
		public void Less(float arg1, float arg2, string message, params object[] args)
		{
			Assert.Less(arg1, arg2, message, args);
		}

		/// <summary>
		/// Verifies that the first value is less than the second value. If it is
		/// not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="arg1">The first value, expected to be less.</param>
		/// <param name="arg2">The second value, expected to be less.</param>
		/// <param name="message">The message to display in case of failure.</param>
		/// <param name="args">Array of objects to be used in formatting the message.</param>
		public void Less(IComparable arg1, IComparable arg2, string message, params object[] args)
		{
			Assert.Less(arg1, arg2, message, args);
		}

		/// <summary>
		/// Verifies that the first value is less than the second value. If it is
		/// not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="arg1">The first value, expected to be less.</param>
		/// <param name="arg2">The second value, expected to be less.</param>
		/// <param name="message">The message to display in case of failure.</param>
		/// <param name="args">Array of objects to be used in formatting the message.</param>
		public void Less(int arg1, int arg2, string message, params object[] args)
		{
			Assert.Less(arg1, arg2, message, args);
		}

		/// <summary>
		/// Verifies that the first value is less than the second value. If it is
		/// not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="arg1">The first value, expected to be less.</param>
		/// <param name="arg2">The second value, expected to be less.</param>
		/// <param name="message">The message to display in case of failure.</param>
		/// <param name="args">Array of objects to be used in formatting the message.</param>
		public void Less(long arg1, long arg2, string message, params object[] args)
		{
			Assert.Less(arg1, arg2, message, args);
		}

		/// <summary>
		/// Verifies that the first value is less than the second value. If it is
		/// not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="arg1">The first value, expected to be less.</param>
		/// <param name="arg2">The second value, expected to be less.</param>
		/// <param name="message">The message to display in case of failure.</param>
		/// <param name="args">Array of objects to be used in formatting the message.</param>
		public void Less(uint arg1, uint arg2, string message, params object[] args)
		{
			Assert.Less(arg1, arg2, message, args);
		}

		/// <summary>
		/// Verifies that the first value is less than the second value. If it is
		/// not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="arg1">The first value, expected to be less.</param>
		/// <param name="arg2">The second value, expected to be less.</param>
		/// <param name="message">The message to display in case of failure.</param>
		/// <param name="args">Array of objects to be used in formatting the message.</param>
		public void Less(ulong arg1, ulong arg2, string message, params object[] args)
		{
			Assert.Less(arg1, arg2, message, args);
		}

		/// <summary>
		/// Verifies that the first value is less than or equal to the second value. If it is
		/// not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="arg1">The first value, expected to be less than or equal to.</param>
		/// <param name="arg2">The second value, expected to be less than or equal to.</param>
		public void LessOrEqual(decimal arg1, decimal arg2)
		{
			Assert.LessOrEqual(arg1, arg2);
		}

		/// <summary>
		/// Verifies that the first value is less than or equal to the second value. If it is
		/// not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="arg1">The first value, expected to be less than or equal to.</param>
		/// <param name="arg2">The second value, expected to be less than or equal to.</param>
		public void LessOrEqual(double arg1, double arg2)
		{
			Assert.LessOrEqual(arg1, arg2);
		}

		/// <summary>
		/// Verifies that the first value is less than or equal to the second value. If it is
		/// not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="arg1">The first value, expected to be less than or equal to.</param>
		/// <param name="arg2">The second value, expected to be less than or equal to.</param>
		public void LessOrEqual(float arg1, float arg2)
		{
			Assert.LessOrEqual(arg1, arg2);
		}

		/// <summary>
		/// Verifies that the first value is less than or equal to the second value. If it is
		/// not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="arg1">The first value, expected to be less than or equal to.</param>
		/// <param name="arg2">The second value, expected to be less than or equal to.</param>
		public void LessOrEqual(IComparable arg1, IComparable arg2)
		{
			Assert.LessOrEqual(arg1, arg2);
		}

		/// <summary>
		/// Verifies that the first value is less than or equal to the second value. If it is
		/// not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="arg1">The first value, expected to be less than or equal to.</param>
		/// <param name="arg2">The second value, expected to be less than or equal to.</param>
		public void LessOrEqual(int arg1, int arg2)
		{
			Assert.LessOrEqual(arg1, arg2);
		}

		/// <summary>
		/// Verifies that the first value is less than or equal to the second value. If it is
		/// not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="arg1">The first value, expected to be less than or equal to.</param>
		/// <param name="arg2">The second value, expected to be less than or equal to.</param>
		public void LessOrEqual(long arg1, long arg2)
		{
			Assert.LessOrEqual(arg1, arg2);
		}

		/// <summary>
		/// Verifies that the first value is less than or equal to the second value. If it is
		/// not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="arg1">The first value, expected to be less than or equal to.</param>
		/// <param name="arg2">The second value, expected to be less than or equal to.</param>
		public void LessOrEqual(uint arg1, uint arg2)
		{
			Assert.LessOrEqual(arg1, arg2);
		}

		/// <summary>
		/// Verifies that the first value is less than or equal to the second value. If it is
		/// not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="arg1">The first value, expected to be less than or equal to.</param>
		/// <param name="arg2">The second value, expected to be less than or equal to.</param>
		public void LessOrEqual(ulong arg1, ulong arg2)
		{
			Assert.LessOrEqual(arg1, arg2);
		}

		/// <summary>
		/// Verifies that the first value is less than or equal to the second value. If it is
		/// not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="arg1">The first value, expected to be less than or equal to.</param>
		/// <param name="arg2">The second value, expected to be less than or equal to.</param>
		/// <param name="message">The message to display in case of failure.</param>
		public void LessOrEqual(decimal arg1, decimal arg2, string message)
		{
			Assert.LessOrEqual(arg1, arg2, message);
		}

		/// <summary>
		/// Verifies that the first value is less than or equal to the second value. If it is
		/// not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="arg1">The first value, expected to be less than or equal to.</param>
		/// <param name="arg2">The second value, expected to be less than or equal to.</param>
		/// <param name="message">The message to display in case of failure.</param>
		public void LessOrEqual(double arg1, double arg2, string message)
		{
			Assert.LessOrEqual(arg1, arg2, message);
		}

		/// <summary>
		/// Verifies that the first value is less than or equal to the second value. If it is
		/// not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="arg1">The first value, expected to be less than or equal to.</param>
		/// <param name="arg2">The second value, expected to be less than or equal to.</param>
		/// <param name="message">The message to display in case of failure.</param>
		public void LessOrEqual(float arg1, float arg2, string message)
		{
			Assert.LessOrEqual(arg1, arg2, message);
		}

		/// <summary>
		/// Verifies that the first value is less than or equal to the second value. If it is
		/// not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="arg1">The first value, expected to be less than or equal to.</param>
		/// <param name="arg2">The second value, expected to be less than or equal to.</param>
		/// <param name="message">The message to display in case of failure.</param>
		public void LessOrEqual(IComparable arg1, IComparable arg2, string message)
		{
			Assert.LessOrEqual(arg1, arg2, message);
		}

		/// <summary>
		/// Verifies that the first value is less than or equal to the second value. If it is
		/// not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="arg1">The first value, expected to be less than or equal to.</param>
		/// <param name="arg2">The second value, expected to be less than or equal to.</param>
		/// <param name="message">The message to display in case of failure.</param>
		public void LessOrEqual(int arg1, int arg2, string message)
		{
			Assert.LessOrEqual(arg1, arg2, message);
		}

		/// <summary>
		/// Verifies that the first value is less than or equal to the second value. If it is
		/// not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="arg1">The first value, expected to be less than or equal to.</param>
		/// <param name="arg2">The second value, expected to be less than or equal to.</param>
		/// <param name="message">The message to display in case of failure.</param>
		public void LessOrEqual(long arg1, long arg2, string message)
		{
			Assert.LessOrEqual(arg1, arg2, message);
		}

		/// <summary>
		/// Verifies that the first value is less than or equal to the second value. If it is
		/// not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="arg1">The first value, expected to be less than or equal to.</param>
		/// <param name="arg2">The second value, expected to be less than or equal to.</param>
		/// <param name="message">The message to display in case of failure.</param>
		public void LessOrEqual(uint arg1, uint arg2, string message)
		{
			Assert.LessOrEqual(arg1, arg2, message);
		}

		/// <summary>
		/// Verifies that the first value is less than or equal to the second value. If it is
		/// not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="arg1">The first value, expected to be less than or equal to.</param>
		/// <param name="arg2">The second value, expected to be less than or equal to.</param>
		/// <param name="message">The message to display in case of failure.</param>
		public void LessOrEqual(ulong arg1, ulong arg2, string message)
		{
			Assert.LessOrEqual(arg1, arg2, message);
		}

		/// <summary>
		/// Verifies that the first value is less than or equal to the second value. If it is
		/// not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="arg1">The first value, expected to be less than or equal to.</param>
		/// <param name="arg2">The second value, expected to be less than or equal to.</param>
		/// <param name="message">The message to display in case of failure.</param>
		/// <param name="args">Array of objects to be used in formatting the message.</param>
		public void LessOrEqual(decimal arg1, decimal arg2, string message, params object[] args)
		{
			Assert.LessOrEqual(arg1, arg2, message, args);
		}

		/// <summary>
		/// Verifies that the first value is less than or equal to the second value. If it is
		/// not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="arg1">The first value, expected to be less than or equal to.</param>
		/// <param name="arg2">The second value, expected to be less than or equal to.</param>
		/// <param name="message">The message to display in case of failure.</param>
		/// <param name="args">Array of objects to be used in formatting the message.</param>
		public void LessOrEqual(double arg1, double arg2, string message, params object[] args)
		{
			Assert.LessOrEqual(arg1, arg2, message, args);
		}

		/// <summary>
		/// Verifies that the first value is less than or equal to the second value. If it is
		/// not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="arg1">The first value, expected to be less than or equal to.</param>
		/// <param name="arg2">The second value, expected to be less than or equal to.</param>
		/// <param name="message">The message to display in case of failure.</param>
		/// <param name="args">Array of objects to be used in formatting the message.</param>
		public void LessOrEqual(float arg1, float arg2, string message, params object[] args)
		{
			Assert.LessOrEqual(arg1, arg2, message, args);
		}

		/// <summary>
		/// Verifies that the first value is less than or equal to the second value. If it is
		/// not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="arg1">The first value, expected to be less than or equal to.</param>
		/// <param name="arg2">The second value, expected to be less than or equal to.</param>
		/// <param name="message">The message to display in case of failure.</param>
		/// <param name="args">Array of objects to be used in formatting the message.</param>
		public void LessOrEqual(IComparable arg1, IComparable arg2, string message, params object[] args)
		{
			Assert.LessOrEqual(arg1, arg2, message, args);
		}

		/// <summary>
		/// Verifies that the first value is less than or equal to the second value. If it is
		/// not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="arg1">The first value, expected to be less than or equal to.</param>
		/// <param name="arg2">The second value, expected to be less than or equal to.</param>
		/// <param name="message">The message to display in case of failure.</param>
		/// <param name="args">Array of objects to be used in formatting the message.</param>
		public void LessOrEqual(int arg1, int arg2, string message, params object[] args)
		{
			Assert.LessOrEqual(arg1, arg2, message, args);
		}

		/// <summary>
		/// Verifies that the first value is less than or equal to the second value. If it is
		/// not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="arg1">The first value, expected to be less than or equal to.</param>
		/// <param name="arg2">The second value, expected to be less than or equal to.</param>
		/// <param name="message">The message to display in case of failure.</param>
		/// <param name="args">Array of objects to be used in formatting the message.</param>
		public void LessOrEqual(long arg1, long arg2, string message, params object[] args)
		{
			Assert.LessOrEqual(arg1, arg2, message, args);
		}

		/// <summary>
		/// Verifies that the first value is less than or equal to the second value. If it is
		/// not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="arg1">The first value, expected to be less than or equal to.</param>
		/// <param name="arg2">The second value, expected to be less than or equal to.</param>
		/// <param name="message">The message to display in case of failure.</param>
		/// <param name="args">Array of objects to be used in formatting the message.</param>
		public void LessOrEqual(uint arg1, uint arg2, string message, params object[] args)
		{
			Assert.LessOrEqual(arg1, arg2, message, args);
		}

		/// <summary>
		/// Verifies that the first value is less than or equal to the second value. If it is
		/// not, then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="arg1">The first value, expected to be less than or equal to.</param>
		/// <param name="arg2">The second value, expected to be less than or equal to.</param>
		/// <param name="message">The message to display in case of failure.</param>
		/// <param name="args">Array of objects to be used in formatting the message.</param>
		public void LessOrEqual(ulong arg1, ulong arg2, string message, params object[] args)
		{
			Assert.LessOrEqual(arg1, arg2, message, args);
		}

		#endregion

		#region Empty / Not Empty

		/// <summary>
		///  Assert that an array, list or other collection is empty.
		/// </summary>
		/// <param name="collection">An array, list or other collection implementing <see cref="ICollection"/>.</param>
		public void IsEmpty(ICollection collection)
		{
			Assert.IsEmpty(collection);
		}

		/// <summary>
		///  Assert that an array, list or other collection is empty.
		/// </summary>
		/// <param name="collection">An array, list or other collection implementing <see cref="ICollection"/>.</param>
		/// <param name="message">The message to display in case of failure.</param>
		public void IsEmpty(ICollection collection, string message)
		{
			Assert.IsEmpty(collection, message);
		}

		/// <summary>
		/// Assert that an array, list or other collection is empty.
		/// </summary>
		/// <param name="collection">An array, list or other collection implementing <see cref="ICollection"/>.</param>
		/// <param name="message">The message to display in case of failure.</param>
		/// <param name="args">Array of objects to be used in formatting the message.</param>
		public void IsEmpty(ICollection collection, string message, params object[] args)
		{
			Assert.IsEmpty(collection, message, args);
		}

		/// <summary>
		/// Assert that a string is empty - that is equal to string.Empty.
		/// </summary>
		/// <param name="aString">The string to be tested.</param>
		public void IsEmpty(string aString)
		{
			Assert.IsEmpty(aString);
		}

		/// <summary>
		/// Assert that a string is empty - that is equal to string.Empty.
		/// </summary>
		/// <param name="aString">The string to be tested.</param>
		/// <param name="message">The message to display in case of failure.</param>
		public void IsEmpty(string aString, string message)
		{
			Assert.IsEmpty(aString, message);
		}

		/// <summary>
		/// Assert that a string is empty - that is equal to string.Empty.
		/// </summary>
		/// <param name="aString">The string to be tested.</param>
		/// <param name="message">The message to display in case of failure.</param>
		/// <param name="args">Array of objects to be used in formatting the message.</param>
		public void IsEmpty(string aString, string message, params object[] args)
		{
			Assert.IsEmpty(aString, message, args);
		}

		/// <summary>
		/// Assert that an array, list or other collection is not empty.
		/// </summary>
		/// <param name="collection">An array, list or other collection implementing <see cref="ICollection"/>.</param>
		public void IsNotEmpty(ICollection collection)
		{
			Assert.IsNotEmpty(collection);
		}

		/// <summary>
		/// Assert that an array, list or other collection is not empty.
		/// </summary>
		/// <param name="collection">An array, list or other collection implementing <see cref="ICollection"/>.</param>
		/// <param name="message">The message to display in case of failure.</param>
		public void IsNotEmpty(ICollection collection, string message)
		{
			Assert.IsNotEmpty(collection, message);
		}

		/// <summary>
		/// Assert that an array, list or other collection is not empty.
		/// </summary>
		/// <param name="collection">An array, list or other collection implementing <see cref="ICollection"/>.</param>
		/// <param name="message">The message to display in case of failure.</param>
		/// <param name="args">Array of objects to be used in formatting the message.</param>
		public void IsNotEmpty(ICollection collection, string message, params object[] args)
		{
			Assert.IsNotEmpty(collection, message, args);
		}

		/// <summary>
		/// Assert that a string is not empty - that is not equal to string.Empty.
		/// </summary>
		/// <param name="aString">The string to be tested.</param>
		public void IsNotEmpty(string aString)
		{
			Assert.IsNotEmpty(aString);
		}

		/// <summary>
		/// Assert that a string is not empty - that is not equal to string.Empty.
		/// </summary>
		/// <param name="aString">The string to be tested.</param>
		/// <param name="message">The message to display in case of failure.</param>
		public void IsNotEmpty(string aString, string message)
		{
			Assert.IsNotEmpty(aString, message);
		}

		/// <summary>
		/// Assert that a string is not empty - that is not equal to string.Empty.
		/// </summary>
		/// <param name="aString">The string to be tested.</param>
		/// <param name="message">The message to display in case of failure.</param>
		/// <param name="args">Array of objects to be used in formatting the message.</param>
		public void IsNotEmpty(string aString, string message, params object[] args)
		{
			Assert.IsNotEmpty(aString, message, args);
		}

		#endregion

		#region Not a Number

		/// <summary>
		/// Verifies that the double that is passed in is an NaN value.  If the object
		/// is not NaN then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="aDouble">The value that is to be tested.</param>
		public void IsNaN(double aDouble)
		{
			Assert.IsNaN(aDouble);
		}

		/// <summary>
		/// Verifies that the double that is passed in is an NaN value.  If the object
		/// is not NaN then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="aDouble">The value that is to be tested.</param>
		public void IsNaN(double? aDouble)
		{
			Assert.IsNaN(aDouble);
		}

		/// <summary>
		/// Verifies that the double that is passed in is an NaN value.  If the object
		/// is not NaN then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="aDouble">The value that is to be tested.</param>
		/// <param name="message">The message to display in case of failure.</param>
		public void IsNaN(double aDouble, string message)
		{
			Assert.IsNaN(aDouble, message);
		}

		/// <summary>
		/// Verifies that the double that is passed in is an NaN value.  If the object
		/// is not NaN then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="aDouble">The value that is to be tested.</param>
		/// <param name="message">The message to display in case of failure.</param>
		public void IsNaN(double? aDouble, string message)
		{
			Assert.IsNaN(aDouble, message);
		}

		/// <summary>
		/// Verifies that the double that is passed in is an NaN value.  If the object
		/// is not NaN then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="aDouble">The value that is to be tested.</param>
		/// <param name="message">The message to display in case of failure.</param>
		/// <param name="args">Array of objects to be used in formatting the message.</param>
		public void IsNaN(double aDouble, string message, params object[] args)
		{
			Assert.IsNaN(aDouble, message, args);
		}

		/// <summary>
		/// Verifies that the double that is passed in is an NaN value.  If the object
		/// is not NaN then an <see cref="AssertionException"/> is thrown.
		/// </summary>
		/// <param name="aDouble">The value that is to be tested.</param>
		/// <param name="message">The message to display in case of failure.</param>
		/// <param name="args">Array of objects to be used in formatting the message.</param>
		public void IsNaN(double? aDouble, string message, params object[] args)
		{
			Assert.IsNaN(aDouble, message, args);
		}

		#endregion

		/// <summary>
		/// Executes the test.
		/// </summary>
		/// <param name="testAction">The test action.</param>
		/// <param name="format">The format.</param>
		/// <param name="args">The args.</param>
		/// <returns></returns>
		private TestResult ExecuteTest(
			Action testAction,
			string format,
			params object[] args)
		{
			var description = string.Format(CultureInfo.CurrentCulture, format, args);

			var testResult = this.ExecuteTest(testAction, description);

			return testResult;
		}

		/// <summary>
		/// Executes the test.
		/// </summary>
		/// <param name="testAction">The test action.</param>
		/// <param name="description">The description.</param>
		/// <returns></returns>
		private TestResult ExecuteTest(
			Action testAction,
			string description = "")
		{
			TestResult testResult = null;

			try
			{
				testAction();

				Trace.TraceInformation("Test \"{0}\" succeeded", description);

				testResult = new TestResult(TestStatus.Succeeded, description);
			}
			catch (AssertionException assertionException)
			{
				Trace.TraceWarning("Test \"{0}\" failed with the message {1}", description, assertionException.Message.Trim());

				testResult = new TestResult(TestStatus.Failed, description, assertionException.Message.Trim());
			}
			catch (Exception exception)
			{
				Trace.TraceError("Test \"{0}\" had an unexpected error with the message {0}", exception.Message);

				testResult = new TestResult(TestStatus.Error, description, exception.Message);
			}

			this._testResultLoggingService.Results.Add(testResult);

			return testResult;
		}




		/* NOPE or LATER */


		/*
			// Summary:
			//     Throws a NUnit.Framework.SuccessException with the message and arguments
			//     that are passed in. This allows a test to be cut short, with a result of
			//     success returned to NUnit.
			public static void Pass();
			//
			// Summary:
			//     Throws a NUnit.Framework.SuccessException with the message and arguments
			//     that are passed in. This allows a test to be cut short, with a result of
			//     success returned to NUnit.
			//
			// Parameters:
			//   message:
			//     The message to initialize the NUnit.Framework.AssertionException with.
			public static void Pass(string message);
			//
			// Summary:
			//     Throws a NUnit.Framework.SuccessException with the message and arguments
			//     that are passed in. This allows a test to be cut short, with a result of
			//     success returned to NUnit.
			//
			// Parameters:
			//   message:
			//     The message to initialize the NUnit.Framework.AssertionException with.
			//
			//   args:
			//     Arguments to be used in formatting the message
			public static void Pass(string message, params object[] args);
			//
			// Summary:
			//     override the default ReferenceEquals to throw an AssertionException. This
			//     implementation makes sure there is no mistake in calling this function as
			//     part of Assert.
			//
			// Parameters:
			//   a:
			//
			//   b:
			public static void ReferenceEquals(object a, object b);
			//
			// Summary:
			//     Asserts that a condition is true. If the condition is false the method throws
			//     an NUnit.Framework.AssertionException.
			//
			// Parameters:
			//   condition:
			//     The evaluated condition
			public static void That(bool condition);
			//
			// Summary:
			//     Apply a constraint to an actual value, succeeding if the constraint is satisfied
			//     and throwing an assertion exception on failure.
			//
			// Parameters:
			//   expr:
			//     A Constraint expression to be applied
			//
			//   del:
			//     An ActualValueDelegate returning the value to be tested
			public static void That(ActualValueDelegate del, IResolveConstraint expr);
			//
			// Summary:
			//     Asserts that a condition is true. If the condition is false the method throws
			//     an NUnit.Framework.AssertionException.
			//
			// Parameters:
			//   condition:
			//     The evaluated condition
			//
			//   message:
			//     The message to display if the condition is false
			public static void That(bool condition, string message);
			//
			// Summary:
			//     Apply a constraint to an actual value, succeeding if the constraint is satisfied
			//     and throwing an assertion exception on failure.
			//
			// Parameters:
			//   expression:
			//     A Constraint to be applied
			//
			//   actual:
			//     The actual value to test
			public static void That(object actual, IResolveConstraint expression);
			//
			// Summary:
			//     Apply a constraint to a referenced value, succeeding if the constraint is
			//     satisfied and throwing an assertion exception on failure.
			//
			// Parameters:
			//   expression:
			//     A Constraint to be applied
			//
			//   actual:
			//     The actual value to test
			public static void That<T>(ref T actual, IResolveConstraint expression);
			//
			// Summary:
			//     Asserts that the code represented by a delegate throws an exception that
			//     satisfies the constraint provided.
			//
			// Parameters:
			//   code:
			//     A TestDelegate to be executed
			//
			//   constraint:
			//     A ThrowsConstraint used in the test
			public static void That(TestDelegate code, IResolveConstraint constraint);
			//
			// Summary:
			//     Apply a constraint to an actual value, succeeding if the constraint is satisfied
			//     and throwing an assertion exception on failure.
			//
			// Parameters:
			//   expr:
			//     A Constraint expression to be applied
			//
			//   del:
			//     An ActualValueDelegate returning the value to be tested
			//
			//   message:
			//     The message that will be displayed on failure
			public static void That(ActualValueDelegate del, IResolveConstraint expr, string message);
			//
			// Summary:
			//     Asserts that a condition is true. If the condition is false the method throws
			//     an NUnit.Framework.AssertionException.
			//
			// Parameters:
			//   condition:
			//     The evaluated condition
			//
			//   message:
			//     The message to display if the condition is false
			//
			//   args:
			//     Arguments to be used in formatting the message
			public static void That(bool condition, string message, params object[] args);
			//
			// Summary:
			//     Apply a constraint to an actual value, succeeding if the constraint is satisfied
			//     and throwing an assertion exception on failure.
			//
			// Parameters:
			//   expression:
			//     A Constraint to be applied
			//
			//   actual:
			//     The actual value to test
			//
			//   message:
			//     The message that will be displayed on failure
			public static void That(object actual, IResolveConstraint expression, string message);
			//
			// Summary:
			//     Apply a constraint to a referenced value, succeeding if the constraint is
			//     satisfied and throwing an assertion exception on failure.
			//
			// Parameters:
			//   expression:
			//     A Constraint to be applied
			//
			//   actual:
			//     The actual value to test
			//
			//   message:
			//     The message that will be displayed on failure
			public static void That<T>(ref T actual, IResolveConstraint expression, string message);
			//
			// Summary:
			//     Apply a constraint to an actual value, succeeding if the constraint is satisfied
			//     and throwing an assertion exception on failure.
			//
			// Parameters:
			//   del:
			//     An ActualValueDelegate returning the value to be tested
			//
			//   expr:
			//     A Constraint expression to be applied
			//
			//   message:
			//     The message that will be displayed on failure
			//
			//   args:
			//     Arguments to be used in formatting the message
			public static void That(ActualValueDelegate del, IResolveConstraint expr, string message, params object[] args);
			//
			// Summary:
			//     Apply a constraint to an actual value, succeeding if the constraint is satisfied
			//     and throwing an assertion exception on failure.
			//
			// Parameters:
			//   expression:
			//     A Constraint expression to be applied
			//
			//   actual:
			//     The actual value to test
			//
			//   message:
			//     The message that will be displayed on failure
			//
			//   args:
			//     Arguments to be used in formatting the message
			public static void That(object actual, IResolveConstraint expression, string message, params object[] args);
			//
			// Summary:
			//     Apply a constraint to a referenced value, succeeding if the constraint is
			//     satisfied and throwing an assertion exception on failure.
			//
			// Parameters:
			//   expression:
			//     A Constraint to be applied
			//
			//   actual:
			//     The actual value to test
			//
			//   message:
			//     The message that will be displayed on failure
			//
			//   args:
			//     Arguments to be used in formatting the message
			public static void That<T>(ref T actual, IResolveConstraint expression, string message, params object[] args);
			//
			// Summary:
			//     Verifies that a delegate throws a particular exception when called.
			//
			// Parameters:
			//   code:
			//     A TestSnippet delegate
			//
			// Type parameters:
			//   T:
			//     Type of the expected exception
			public static T Throws<T>(TestDelegate code) where T : Exception;
			//
			// Summary:
			//     Verifies that a delegate throws a particular exception when called.
			//
			// Parameters:
			//   expression:
			//     A constraint to be satisfied by the exception
			//
			//   code:
			//     A TestSnippet delegate
			public static Exception Throws(IResolveConstraint expression, TestDelegate code);
			//
			// Summary:
			//     Verifies that a delegate throws a particular exception when called.
			//
			// Parameters:
			//   code:
			//     A TestSnippet delegate
			//
			//   message:
			//     The message that will be displayed on failure
			//
			// Type parameters:
			//   T:
			//     Type of the expected exception
			public static T Throws<T>(TestDelegate code, string message) where T : Exception;
			//
			// Summary:
			//     Verifies that a delegate throws a particular exception when called.
			//
			// Parameters:
			//   expectedExceptionType:
			//     The exception Type expected
			//
			//   code:
			//     A TestSnippet delegate
			public static Exception Throws(Type expectedExceptionType, TestDelegate code);
			//
			// Summary:
			//     Verifies that a delegate throws a particular exception when called.
			//
			// Parameters:
			//   expression:
			//     A constraint to be satisfied by the exception
			//
			//   code:
			//     A TestSnippet delegate
			//
			//   message:
			//     The message that will be displayed on failure
			public static Exception Throws(IResolveConstraint expression, TestDelegate code, string message);
			//
			// Summary:
			//     Verifies that a delegate throws a particular exception when called.
			//
			// Parameters:
			//   code:
			//     A TestSnippet delegate
			//
			//   message:
			//     The message that will be displayed on failure
			//
			//   args:
			//     Arguments to be used in formatting the message
			//
			// Type parameters:
			//   T:
			//     Type of the expected exception
			public static T Throws<T>(TestDelegate code, string message, params object[] args) where T : Exception;
			//
			// Summary:
			//     Verifies that a delegate throws a particular exception when called.
			//
			// Parameters:
			//   expectedExceptionType:
			//     The exception Type expected
			//
			//   code:
			//     A TestSnippet delegate
			//
			//   message:
			//     The message that will be displayed on failure
			public static Exception Throws(Type expectedExceptionType, TestDelegate code, string message);
			//
			// Summary:
			//     Verifies that a delegate throws a particular exception when called.
			//
			// Parameters:
			//   expression:
			//     A constraint to be satisfied by the exception
			//
			//   code:
			//     A TestSnippet delegate
			//
			//   message:
			//     The message that will be displayed on failure
			//
			//   args:
			//     Arguments to be used in formatting the message
			public static Exception Throws(IResolveConstraint expression, TestDelegate code, string message, params object[] args);
			//
			// Summary:
			//     Verifies that a delegate throws a particular exception when called.
			//
			// Parameters:
			//   expectedExceptionType:
			//     The exception Type expected
			//
			//   code:
			//     A TestSnippet delegate
			//
			//   message:
			//     The message that will be displayed on failure
			//
			//   args:
			//     Arguments to be used in formatting the message
			public static Exception Throws(Type expectedExceptionType, TestDelegate code, string message, params object[] args);
			//*/


		/*
			// Summary:
			//     Throws an NUnit.Framework.IgnoreException. This causes the test to be reported
			//     as ignored.
			public static void Ignore();
			//
			// Summary:
			//     Throws an NUnit.Framework.IgnoreException with the message that is passed
			//     in. This causes the test to be reported as ignored.
			//
			// Parameters:
			//   message:
			//     The message to initialize the NUnit.Framework.AssertionException with.
			public static void Ignore(string message);
			//
			// Summary:
			//     Throws an NUnit.Framework.IgnoreException with the message and arguments
			//     that are passed in. This causes the test to be reported as ignored.
			//
			// Parameters:
			//   message:
			//     The message to initialize the NUnit.Framework.AssertionException with.
			//
			//   args:
			//     Arguments to be used in formatting the message
			public static void Ignore(string message, params object[] args);
			//
			// Summary:
			//     Throws an NUnit.Framework.InconclusiveException. This causes the test to
			//     be reported as Inconclusive.
			public static void Inconclusive();
			//
			// Summary:
			//     Throws an NUnit.Framework.InconclusiveException with the message that is
			//     passed in. This causes the test to be reported as inconclusive.
			//
			// Parameters:
			//   message:
			//     The message to initialize the NUnit.Framework.InconclusiveException with.
			public static void Inconclusive(string message);
			//
			// Summary:
			//     Throws an NUnit.Framework.InconclusiveException with the message and arguments
			//     that are passed in. This causes the test to be reported as inconclusive.
			//
			// Parameters:
			//   message:
			//     The message to initialize the NUnit.Framework.InconclusiveException with.
			//
			//   args:
			//     Arguments to be used in formatting the message
			public static void Inconclusive(string message, params object[] args);
		 */

		/*
			//
			// Summary:
			//     Asserts that an object may be assigned a value of a given Type.
			//
			// Parameters:
			//   actual:
			//     The object under examination
			//
			// Type parameters:
			//   T:
			//     The expected Type.
			public static void IsAssignableFrom<T>(object actual);
			//
			// Summary:
			//     Asserts that an object may be assigned a value of a given Type.
			//
			// Parameters:
			//   actual:
			//     The object under examination
			//
			//   message:
			//     The message to display in case of failure
			//
			// Type parameters:
			//   T:
			//     The expected Type.
			public static void IsAssignableFrom<T>(object actual, string message);
			//
			// Summary:
			//     Asserts that an object may be assigned a value of a given Type.
			//
			// Parameters:
			//   expected:
			//     The expected Type.
			//
			//   actual:
			//     The object under examination
			public static void IsAssignableFrom(Type expected, object actual);
			//
			// Summary:
			//     Asserts that an object may be assigned a value of a given Type.
			//
			// Parameters:
			//   actual:
			//     The object under examination
			//
			//   message:
			//     The message to display in case of failure
			//
			//   args:
			//     Array of objects to be used in formatting the message
			//
			// Type parameters:
			//   T:
			//     The expected Type.
			public static void IsAssignableFrom<T>(object actual, string message, params object[] args);
			//
			// Summary:
			//     Asserts that an object may be assigned a value of a given Type.
			//
			// Parameters:
			//   expected:
			//     The expected Type.
			//
			//   actual:
			//     The object under examination
			//
			//   message:
			//     The message to display in case of failure
			public static void IsAssignableFrom(Type expected, object actual, string message);
			//
			// Summary:
			//     Asserts that an object may be assigned a value of a given Type.
			//
			// Parameters:
			//   expected:
			//     The expected Type.
			//
			//   actual:
			//     The object under examination
			//
			//   message:
			//     The message to display in case of failure
			//
			//   args:
			//     Array of objects to be used in formatting the message
			public static void IsAssignableFrom(Type expected, object actual, string message, params object[] args);
			//
			// Summary:
			//     Asserts that an object is an instance of a given type.
			//
			// Parameters:
			//   actual:
			//     The object being examined
			//
			// Type parameters:
			//   T:
			//     The expected Type
			public static void IsInstanceOf<T>(object actual);
			//
			// Summary:
			//     Asserts that an object is an instance of a given type.
			//
			// Parameters:
			//   actual:
			//     The object being examined
			//
			//   message:
			//     The message to display in case of failure
			//
			// Type parameters:
			//   T:
			//     The expected Type
			public static void IsInstanceOf<T>(object actual, string message);
			//
			// Summary:
			//     Asserts that an object is an instance of a given type.
			//
			// Parameters:
			//   expected:
			//     The expected Type
			//
			//   actual:
			//     The object being examined
			public static void IsInstanceOf(Type expected, object actual);
			//
			// Summary:
			//     Asserts that an object is an instance of a given type.
			//
			// Parameters:
			//   actual:
			//     The object being examined
			//
			//   message:
			//     The message to display in case of failure
			//
			//   args:
			//     Array of objects to be used in formatting the message
			//
			// Type parameters:
			//   T:
			//     The expected Type
			public static void IsInstanceOf<T>(object actual, string message, params object[] args);
			//
			// Summary:
			//     Asserts that an object is an instance of a given type.
			//
			// Parameters:
			//   expected:
			//     The expected Type
			//
			//   actual:
			//     The object being examined
			//
			//   message:
			//     The message to display in case of failure
			public static void IsInstanceOf(Type expected, object actual, string message);
			//
			// Summary:
			//     Asserts that an object is an instance of a given type.
			//
			// Parameters:
			//   expected:
			//     The expected Type
			//
			//   actual:
			//     The object being examined
			//
			//   message:
			//     The message to display in case of failure
			//
			//   args:
			//     Array of objects to be used in formatting the message
			public static void IsInstanceOf(Type expected, object actual, string message, params object[] args);
			//
			// Summary:
			//     Asserts that an object is an instance of a given type.
			//
			// Parameters:
			//   expected:
			//     The expected Type
			//
			//   actual:
			//     The object being examined
			[Obsolete]
			public static void IsInstanceOfType(Type expected, object actual);
			//
			// Summary:
			//     Asserts that an object is an instance of a given type.
			//
			// Parameters:
			//   expected:
			//     The expected Type
			//
			//   actual:
			//     The object being examined
			//
			//   message:
			//     The message to display in case of failure
			[Obsolete]
			public static void IsInstanceOfType(Type expected, object actual, string message);
			//
			// Summary:
			//     Asserts that an object is an instance of a given type.
			//
			// Parameters:
			//   expected:
			//     The expected Type
			//
			//   actual:
			//     The object being examined
			//
			//   message:
			//     The message to display in case of failure
			//
			//   args:
			//     Array of objects to be used in formatting the message
			[Obsolete]
			public static void IsInstanceOfType(Type expected, object actual, string message, params object[] args);
			//
			//
			// Summary:
			//     Asserts that an object may not be assigned a value of a given Type.
			//
			// Parameters:
			//   actual:
			//     The object under examination
			//
			// Type parameters:
			//   T:
			//     The expected Type.
			public static void IsNotAssignableFrom<T>(object actual);
			//
			// Summary:
			//     Asserts that an object may not be assigned a value of a given Type.
			//
			// Parameters:
			//   actual:
			//     The object under examination
			//
			//   message:
			//     The message to display in case of failure
			//
			// Type parameters:
			//   T:
			//     The expected Type.
			public static void IsNotAssignableFrom<T>(object actual, string message);
			//
			// Summary:
			//     Asserts that an object may not be assigned a value of a given Type.
			//
			// Parameters:
			//   expected:
			//     The expected Type.
			//
			//   actual:
			//     The object under examination
			public static void IsNotAssignableFrom(Type expected, object actual);
			//
			// Summary:
			//     Asserts that an object may not be assigned a value of a given Type.
			//
			// Parameters:
			//   actual:
			//     The object under examination
			//
			//   message:
			//     The message to display in case of failure
			//
			//   args:
			//     Array of objects to be used in formatting the message
			//
			// Type parameters:
			//   T:
			//     The expected Type.
			public static void IsNotAssignableFrom<T>(object actual, string message, params object[] args);
			//
			// Summary:
			//     Asserts that an object may not be assigned a value of a given Type.
			//
			// Parameters:
			//   expected:
			//     The expected Type.
			//
			//   actual:
			//     The object under examination
			//
			//   message:
			//     The message to display in case of failure
			public static void IsNotAssignableFrom(Type expected, object actual, string message);
			//
			// Summary:
			//     Asserts that an object may not be assigned a value of a given Type.
			//
			// Parameters:
			//   expected:
			//     The expected Type.
			//
			//   actual:
			//     The object under examination
			//
			//   message:
			//     The message to display in case of failure
			//
			//   args:
			//     Array of objects to be used in formatting the message
			public static void IsNotAssignableFrom(Type expected, object actual, string message, params object[] args);
			//
			// Summary:
			//     Asserts that an object is not an instance of a given type.
			//
			// Parameters:
			//   actual:
			//     The object being examined
			//
			// Type parameters:
			//   T:
			//     The expected Type
			public static void IsNotInstanceOf<T>(object actual);
			//
			// Summary:
			//     Asserts that an object is not an instance of a given type.
			//
			// Parameters:
			//   actual:
			//     The object being examined
			//
			//   message:
			//     The message to display in case of failure
			//
			// Type parameters:
			//   T:
			//     The expected Type
			public static void IsNotInstanceOf<T>(object actual, string message);
			//
			// Summary:
			//     Asserts that an object is not an instance of a given type.
			//
			// Parameters:
			//   expected:
			//     The expected Type
			//
			//   actual:
			//     The object being examined
			public static void IsNotInstanceOf(Type expected, object actual);
			//
			// Summary:
			//     Asserts that an object is not an instance of a given type.
			//
			// Parameters:
			//   actual:
			//     The object being examined
			//
			//   message:
			//     The message to display in case of failure
			//
			//   args:
			//     Array of objects to be used in formatting the message
			//
			// Type parameters:
			//   T:
			//     The expected Type
			public static void IsNotInstanceOf<T>(object actual, string message, params object[] args);
			//
			// Summary:
			//     Asserts that an object is not an instance of a given type.
			//
			// Parameters:
			//   expected:
			//     The expected Type
			//
			//   actual:
			//     The object being examined
			//
			//   message:
			//     The message to display in case of failure
			public static void IsNotInstanceOf(Type expected, object actual, string message);
			//
			// Summary:
			//     Asserts that an object is not an instance of a given type.
			//
			// Parameters:
			//   expected:
			//     The expected Type
			//
			//   actual:
			//     The object being examined
			//
			//   message:
			//     The message to display in case of failure
			//
			//   args:
			//     Array of objects to be used in formatting the message
			public static void IsNotInstanceOf(Type expected, object actual, string message, params object[] args);
			//
			// Summary:
			//     Asserts that an object is not an instance of a given type.
			//
			// Parameters:
			//   expected:
			//     The expected Type
			//
			//   actual:
			//     The object being examined
			[Obsolete]
			public static void IsNotInstanceOfType(Type expected, object actual);
			//
			// Summary:
			//     Asserts that an object is not an instance of a given type.
			//
			// Parameters:
			//   expected:
			//     The expected Type
			//
			//   actual:
			//     The object being examined
			//
			//   message:
			//     The message to display in case of failure
			[Obsolete]
			public static void IsNotInstanceOfType(Type expected, object actual, string message);
			//
			// Summary:
			//     Asserts that an object is not an instance of a given type.
			//
			// Parameters:
			//   expected:
			//     The expected Type
			//
			//   actual:
			//     The object being examined
			//
			//   message:
			//     The message to display in case of failure
			//
			//   args:
			//     Array of objects to be used in formatting the message
			[Obsolete]
			public static void IsNotInstanceOfType(Type expected, object actual, string message, params object[] args);
			//
		 */
	}
}
